pointeurs vides en C++

Question

j'ai vu cet exemple sur un site Web, et les sites Internet mentionne: - « Une de ses utilisations (pointeurs vides) peut être de passer des paramètres génériques à une fonction »

// increaser 
#include <iostream> 
using namespace std; 

void increase (void* data, int psize) 
{ 
    if (psize == sizeof(char)) 
    { char* pchar; pchar=(char*)data; ++(*pchar); } 
    else if (psize == sizeof(int)) 
    { int* pint; pint=(int*)data; ++(*pint); } 
} 

int main() 
{ 
    char a = 'x'; 
    int b = 1602; 
    increase (&a,sizeof(a)); 
    increase (&b,sizeof(b)); 
    cout << a << ", " << b << endl; 
    return 0; 
} 

wouldn » t-il être plus simple d'écrire du code comme celui-ci?

void increaseChar (char* charData) 
{ 
    ++(*charData); 
} 

void increaseInt (int* intData) 
{ 
    ++(*intData); 
} 

int main() 
{ 
    char a = 'x'; 
    int b = 1602; 
    increaseChar (&a); 
    increaseInt (&b); 
    cout << a << ", " << b << endl; 
    string str; 
    cin >> str; 
    return 0; 
} 

C'est moins de code, et c'est vraiment simple. Et dans le premier code, j'ai dû envoyer la taille du type de données ici, je ne le fais pas!

Answer 1

Votre code est définitivement préférable. void* Ne perd pas de semblant de taper la sécurité, vos surcharges typesafe sont beaucoup mieux. De bons instincts.

Pour prendre en charge plus de types génériques en C++, vous devez définir un modèle de classe ou de fonction, sans utiliser void*. Les références seraient préférables à des pointeurs, mais votre code pourrait être changé à ceci:

template <class T> T increase(T* value) 
{ 
    return ++(*value); 
} 

int main(int argc, char* argv[]) 
{ 
    int i(0); 
    increase<int>(&i); 

    char c(0); 
    increase<char>(&c); 

    return 0; 
} 

Quel est le site, comme une question d'intérêt?

Answer 2

Votre solution ne fonctionne que pour int ou char. Considérez la situation que vous voulez traverser un tableau de type personnalisé (struct, par exemple). Dans votre code, vous devrez ajouter une méthode pour le faire, mais dans l'exemple ci-dessus aucune ligne de could ne devrait être ajoutée pour obtenir l'exemple de travail.

Answer 3

Il est préférable de rendre le type de fonction sûr et générique. Il serait également préférable de prendre l'argument par référence plutôt que par pointeur:

template <typename T> 
void increment(T& data) { 
    ++data; 
} 

void* doit être évitée autant que possible en C++, parce que les modèles et l'héritage offrent des alternatives typées.

Answer 4

« Une de ses utilisations (pointeurs vides) peut être de passer des paramètres génériques à une fonction »

Pas bon usage de style, pour être certain. Le passage de paramètres génériques aux fonctions se fait par:

a) modèles (et spécialisations éventuellement modèle) qui permet d'écrire du code en toute sécurité,
b) approches POO. J'aime votre meilleure solution increaseInt et increaseChar mieux. Vous pouvez réécrire comme:

template<typename T> 
void increase(T* pData) 
{ 
    ++(*pData); 
} 

Il fonctionnera pour tout type qui prend en charge ++ et être en sécurité.

---

Parfois, vous aviez encore besoin d'un pointeur vide comme un « paramètre générique » - par exemple lors de l'utilisation de la bibliothèque pthread populaire. Quand vous lancez un thread, vous pouvez lui envoyer des données arbitraires (de n'importe quel type que vous voulez), et c'est fait en utilisant - bien - un pointeur void*.La bibliothèque pthread est en C non C++, ce qui peut être l'une des raisons, mais vous pourriez vouloir l'interfacer avec C++ et cela nécessitera en effet d'utiliser le pointeur void* comme "type générique". Pas beaucoup de mal fait là, cependant; Rappelez-vous simplement que pour le codage quotidien, il existe des solutions plus élégantes.

Answer 5

En fait, je pense que l'exemple est assez mauvais. Un des exemples canoniques serait qsort de la bibliothèque C, où vous passez en void*ainsi que une fonction qui interprète les données.

Cependant, en C++, il existe de meilleurs mécanismes disponibles qui sont moins susceptibles de mal fonctionner silencieusement.

Par conséquent, l'utilisation de void* pour transmettre des données génériques autour devrait probablement se limiter à

cas

1. où le ballonnement de code est important et
Code
2. qui interagit avec une autre langue, en particulier C.

Answer 6

Lorsque vous programmez C (pas C++) void *, vous pouvez seulement faire quelque chose de générique. Néanmoins, l'exemple est terrible. Ce schéma est souvent utilisé pour la mécanique de callback, où vous passez un pointeur de fonction et un void *. Par exemple:

void handle_crash(void* data) 
{ 
    Log* log = (Log*)data; 
    log->print("We crashed."); 
} 

Log log; 
set_crash_handler(&handle_crash, &log); 

Vous verrez cela souvent sur des frameworks C tels que libxml2 ou spidermonkey. Dans le cas de C, c'est la seule chose à faire pour l'accomplir. Ce n'est pas une solution très robuste. Si vous travaillez avec C++, vous avez plus d'options. La programmation générique de base peut être faite avec des modèles ou une surcharge comme mentionné dans d'autres réponses. Dans le cas où vous avez besoin d'un mécanisme de callback solide, vous pouvez regarder dans libsigC++ ou d'autres frameworks de "signaux et slots".