Pointeur void *

Version imprimable

11/12/2008, 17h50
coberle

Pointeur void *
Bonjour,

Après avoir cherché sans trouver, je me résolu a poster ce post. Je souhaite créer une classe "Liste" générique avec les fonction usuelle de gestion des liste. Les éléments de la liste sont d'un type indéfini. J'ai la méthode add(void *item):
Code:

1 2 3 4 5 6 int ListS::add(void *item) { current=malloc(sizeof(item)); ... }
où current est un pointeur vers l'élément courant de la liste (void *current) et la méthode getCurrent():
Code:

1 2 3 void *ListS::getCurrent() { return current; }
Comment faire pour récupérer la valeur de cet élément courant ? J'ai essayé
Code:

1 2 3 4 int i=5; list->add(&i); printf("%d",*(list->getCurrent()));
qui ne marche pas. J'ai aussi essayé (int) ... sans succès ...

Merci pour votre aide.

Christian
11/12/2008, 18h21
Keweed
Salut,

Tu a un pointeur (current) qui pointe sur une zone de la taille d'un pointeur (une adresse mémoire). Je pense que ce que tu veux plutôt faire c'est faire pointer ton pointeur (current) sur l'élément passer en paramètre à la méthode add(). Pour cela remplace la ligne suivante :

Code:

current=malloc(sizeof(item));

par

Code:

current=item;

Tu essaye ensuite d'afficher la valeur pointée mais c'est un pointeur sur le type void donc je pense que printf() ne sait pas afficher un void. Utilise donc un pointeur intermédiaire de type int et transtype ton type void en int comme cela :
Code:

1 2 3 4 int i=5; list->add(&i); int* temp = (int*) list->getCurrent(); printf("%d \n", *temp);

Si en récupérant la valeur il te faut connaître son type pour l'utiliser, tourne toi vers les templates :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
template<class T>
class Liste
{
public
    int add(T* item);
    T* getCurrent();
private:
    T* current;
};
 
typedef List<int> TIntList;

Tu aura alors

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
template<class T>
int Liste<T>::add(T* item)
{
    current = item;
}
 
template<class T>
T* Liste<T>::getCurrent()
{
    return current;
}

Puis

Code:

1
2
3
4
5
6
 
int i=5;
TIntList* list = new TIntList();
list->add(&i);
int* temp = list->getCurrent();
printf("%d \n", *temp);

Ca évite ce genre de problème à l'exécution :

Code:

1
2
3
4
5
6
 
int i=5;
TIntList* list = new TIntList();
list->add(&i);
double* temp = list->getCurrent(); // erreur de compile
printf("%d \n", *temp);

L'inconvénient est qu'une liste ne contiendra que le même type d'objet. Dans ce cas, templarise juste la méthode pour laisser l'utilisateur transparent :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
class Liste
{
   int add(void* item);
   template<class T> T* getCurrent();
};
 
int Liste::add(void* item)
{
   current = item;
}
 
template<class T> T* Liste::getCurrent()
{
   return static_cast<T*>(current);
}

Et à l'utilisation :

Code:

1
2
3
4
5
 
int i=5;
list->add(&i);
int* temp = list->getCurrent<int>();
printf("%d \n", *temp);

Plus pratique

12/12/2008, 09h20
3DArchi

Si ce n'est pas un exercice de cours, alors tourne toi directement vers la STL.
Sinon, l'utilisation des template est la plus adéquate.
12/12/2008, 14h49
zais_ethael

Mouais.
La seconde solution proposée par mister est tout de même pas franchement terrible vu que cela ne permet pas de gérer le cycle de vie des objets de la liste. Et un objet incapable de détruire correctement les données qu'il contient ça n'est rien de moins qu'une hérésie! Ne parlons même pas des objets polymorphes...
Une collection typée stockant ses objets par valeur est une solution beaucoup intéressante niveau apprentissage du langage. Si on veut vraiment une collection capable de stocker des objets d'un type non connu à la compilation la meilleure solution, celle qui fonctionnerait pour de vrai, pourrait être d'utiliser un std::vector de boost::any.
12/12/2008, 15h06
Alp

En quelques mots, voici ce qu'il faut que tu fasse si tu veux "réinventer la roue" (probablement pour un TP/TD/Examen/Autre, mais tu dois avoir tes raisons sinon tu utiliserais std::list ou similaire).

1/ On ne programme pas en C/C++, ce langage n'existe pas. Soit en C, soit en C++. En C, void* est très utilisé faute de mieux, mais en C++ dans 99% des cas son utilisation est remplacée par celle des templates. Si tu ne connais pas, je t'invite à consulter l'un de nos cours C++, notamment http://bruce-eckel.developpez.com/li...on/ticpp2vol1/, pour y découvrir ce que sont les templates.

2/ Les templates t'aideront pour rendre ta classe générique. Si tu n'as besoin que ce soient que des fonctions qui le soient et de stocker des éléments hétérogènes, alors tourne toi vers boost::any si tu ne connais pas les types des éléments susceptibles d'être mis dans la liste, boost::variant si tu sais exactement quels types d'éléments pourront y être mis.

3/ En C++, on a les mots clés new et delete à la place de malloc, pour l'allocation et la désallocation de mémoire.

4/ En C++, on a les flux standards : std::cout et std::cin à utiliser au lieu de printf, scanf & compagnie.

Bref, tu es en C++ mais tu ne profites pas de sa puissance et de ses facilités, c'est bien dommage. Le cours dont j'ai donné le lien plus haut devrait t'aider à exploiter les facilités et la puissance du C++.
12/12/2008, 16h40
coberle

Merci pour vos réponses très instructives.
Je me forme (en autodidacte) et votre aide m'est précieuse.
Christian
12/12/2008, 20h11
Alp

Si après lecture du cours tu ne comprends pas trop le rapport entre void* et les templates, ou tout autre explication donnée ici, n'hésite pas à nous le signaler ;)