Utilisation des pointeurs

18 juillet 2007 à 13:16:04

Bonjour à tous.
Je voudrais savoir s'il est possible de pointer vers un objet sans que le compilateur ne sache de quel objet il s'agisse. Je vais essayer d'être plus clair :
j'ai un void** (Liste_Selection). Ce void** est un tableau de void*. Chaque void* pointe vers la spécialisation d'une classe template.

L'allocation mémoire de mon void** est dynamique :

Liste_Selection = (void**)malloc(Taille_Tableau * sizeof(void*));

ensuite, je connais le type de donnée que je veux stocker et leur nombre alors je fais par exemple :

Liste_Selection[index] = (CConteneur<long int>*)malloc(sizeof(CConteneur<long int>));

CConteneur est, vous l'aurez deviné, ma classe template.

Mon problème est que quand je veux apeller une méthode de mon objet template, je ne peux pas faire :

(this->Liste_Selection[i])->Allouer_Memoire(...);

Le compilo me dit que void* n'est pas un type de pointeur vers un objet
je suis obligé de faire :

((CConteneur<long int>*)(this->Liste_Selection[i]))->Allouer_Memoire(...);

Mais devoir faire cela m'ennuit.
Je voudrais donc pouvoir pointer vers un objet sans que le compilo ne le connaisse à l'avance (en faisant attention à ma gestion de la mémoire bien sur

ou alors pourvoir passer à CConteneur<> un objet dynamique CConteneur<Type_Varialbe[index]> par exemple.
Si quelqu'un a une idée ba c'est génial.
Je continue de chercher.
Merci d'avance

Nanoc

18 juillet 2007 à 19:40:57

Hello,

2 remarques pour commencer:

1) en C++ on utilise pas malloc mais new.

2) les pointeurs sur void sont des choses à éviter absolument dans la mesure du possible et ici c'est le cas vu que tu pointes vers des sous-classes. Il te suffit de créer un pointeur sur la classe mère, car il peut contenir une classe-fille via la relation d'héritage. (Polymorphisme)

Ensuite pour ton conteneur utilise un std::vector par exemple comme ça tu t'embêtes pas à devoir gérer la mémoire toi-même.

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

int21h

18 juillet 2007 à 19:54:04

Je ne suis pas sûr d'avoir tout à fait compris la question

#include<string>
#include<list>

class CObject{};

class MyObject : public CObject
{
public:
int m_value;

MyObject(int val):m_value(val){};
};

class MyOtherObject : public CObject
{
public:
std::string m_string;

MyOtherObject(const std::string & s):m_string(s){};
};

int main()
{
std::list<CObject *> myList;

CObject * aObject;

aObject = (CObject *)new MyObject(5);

myList.push_back(aObject);

aObject = (CObject *) new MyOtherObject("toto");

myList.push_back(aObject);

}

Et pour les traitements génériques sur les objets, on utilisera des méthodes virtuelles (pure ou pas) de CObject.

Mettre à jour le MinGW Gcc sur Code::Blocks. Du code qui n'existe pas ne contient pas de bug

boule_t

19 juillet 2007 à 13:22:38

Merci de vos réponses. Je vais essayer ces solutions.
J'utilise malloc car j'ai du mal a passer au C++ : je suis un vieux bof de la prog

et j'ai toujours tendance à faire du C, c'est le langage que j'ai apprit en premier et j'aime bien perdre du temps a "réinventer la roue" (je suis étudiant donc c'est pas génant pour l'instant...)
Je vais regarder les listes.
Merci

MatteX

19 juillet 2007 à 16:22:25

Oui mais malloc n'appel pas le constructeur de l'objet alors tu as un espace en mémoire mais rien d'utilisable.

Alp

19 juillet 2007 à 19:10:46

Voir du void* en C++ n'a aucun sens.

Selon les cas, tu peux forcément résoudre ton problème avec l'une de ces deux solutions, voire les deux :
- Polymorphisme d'exécution (1)
- Polymorphisme de compilation (2)

Ici on t'a proposé une solution utilisant (1), par exemple.