Discussion :

[chrtophe]

Bonsoir,

Je souhaites passer en paramètre à une classe l'adresse de la classe créatrice (pour garder son parent). Les 2 classes sont autonomes.

voici l'exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
class FOURMI
{
public:
FOURMI(FOURMILIERE pointeur)
{
 
  _sleep(1);
  QTime time=QTime::currentTime();
  id=QTime().msecsTo(time);
}
 
int getId()
{
  return id;
}
 
private:
int id;
 
};
 
class FOURMILIERE
{
public:
FOURMILIERE()
{
  liste_fourmis=NULL;
  compteur=0;
}
 
void naissance()
{
  ELEMENT *element=new ELEMENT;
  FOURMI *fourmi=new FOURMI(*this);
  element->fourmi=fourmi;
  element->next=liste_fourmis;
  liste_fourmis=element;
  ++compteur;
}
 
 
void liste()
{
  ELEMENT *temp=liste_fourmis;
  while (temp!=NULL)
  {
    qDebug()<<temp->fourmi->getId();
    temp=temp->next;
  }
}
 
int count()
{
  return compteur;
}
 
class ELEMENT
{
public:
  FOURMI *fourmi;
  ELEMENT *next;
};
ELEMENT *liste_fourmis;
int     compteur;
};

Dans mon cas, je cherche à passer en paramètre lors le l'instanciation d'une "fourmi" dans ma méthode naissance l'adresse de la fourmilière. En fait comme parent.

Ça fonctionne si j'enlève le *this de la ligne FOURMI *fourmi=new FOURMI(*this); et que je ne mets pas de paramètre dans mon constructeur.

Mes deux classes sont autonomes, et je souhaites laisser cela comme cela.

Je précise que je ne suis pas développeur de métier.

Merci pour votre aide.

[dragonjoker59]

Si tu initialises la fourmilière de ta fourmi uniquement dans le constructeur, tu peux la stocker en tant que membre référence dans fourmi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class FOURMI
{
public:
    FOURMI( FOURMILIERE & fourmiliere )
        : m_fourmiliere( fourmiliere )
    {
    }
 
    ...
 
private:
    FOURMILIERE & fourmiliere;
};

[ternel]

Bonjour,

Un pointeur ou une référence peut être défini sur un type incomplet, c'est à dire déclaré mais non défini.

Il te suffit de déclarer à l'avance le type à pointer/référer. On parle de déclaration anticipée, ou en anglais on parle de forward declaration.

Voici un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace exemple {
class A; //pas d'accolade, c'est donc la déclaration d'un type A, qui sera une classe
 
class B {
private:
    A* pointeur;
public:
    B(A* that) : pointeur(that) {}
};
 
//définition du type A
class A {};
 
}//exemple::

Il est possible de ne pas définir le type déclaré dans le même en-tête.
Il suffit que la définition soit visible au moment d'appeler la fonction ou classe.

Il y a au moins un exemple dans la STL: <iosfwd> qui déclare les différents streams.
Cela permet de déclarer les opérateurs << et >> pour une classe sans avoir à importer tout iostream.

[chrtophe]

Merci pour vos réponses. Tout cela me parait tordu pour stocker une adresse dans une variable.

Ce que je souhaites :

une fourmi appartient ou non à une fourmilière. Une fourmilière possède ou non des fourmis, les 2 classes sont indépendantes.
Si je crée une fourmi depuis la classe fourmilière, je souhaites lui passer en paramètre l'adresse de l'instance de la fourmilière que je stockerais dans un champ parent.

Je reprendrais ça à tête reposée.

[chrtophe]

Voici la solution que j'ai adopté.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
class FOURMI
{
public:
FOURMI(void *adresse)
{
  std::cout<<this<<"\n";
  std::cout<<"adr appelant "<<adresse<<"\n";
  parent=adresse;
}
FOURMI()
{
  std::cout<<"pas de parametres"<<"\n";
}
 
private:
void *parent=NULL;
};
 
class FOURMILIERE
{
public:
FOURMILIERE()
{
}
 
void naissance()
{
  FOURMI *fourmi=new FOURMI(this);
}
};    
 
int main()
{
  FOURMI *fourmi=new FOURMI();
 
  FOURMILIERE *fourmiliere=new FOURMILIERE;
  fourmiliere->naissance();
  std::cout<<"fourmiliere "<<fourmiliere;
 
}

J'ai déclaré le parent en void. Ça compile et s’exécute.

Si ce champ parent est destiné à être parent de plusieurs types d'objet, c'est adapté, on aura alors besoin d'un mécanisme pour pouvoir dissocier le type. Si le seul type possible de parent est FOURMILIERE, c'est pas grave de laisser en void, mais c'est pas propre et il faudra caster si nécessaire. Si je change le type de parent de void vers FOURMILIERE, ça ne compile pas. Je pense que c'est du au fait que la classe FOURMILIERE est déclaré après. Mais si j'inverse le positionnement des classes, je vais avoir le même problème car dans FOURMILIERE->naissance(), je crée une instance de FOURMI.

Je peux laisser comme ça mais suis ouvert à tout commentaire ou proposition d'améliorations. Par contre, les exemples et explications m'ayant été fournis ne me parlent pas, je fais pas assez de C++ pour cela.

[Médinoc]

void*? Je ne vois aucun intérêt à utiliser un void* ici.
Si la fourmi ne peut pas changer de fourmilière au long de sa vie, il convient d'utiliser une référence. Si elle peut changer de fourmilière, un pointeur.

Exemple avec référence:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <iostream>
#include <vector>
 
class FOURMILIERE;
 
class FOURMI
{
public:
	explicit FOURMI(FOURMILIERE & parent) : parent(parent)
	{
		std::cout<<this<<"\n";
		void* adresse = &parent;
		std::cout<<"Fourmiliere parente "<<adresse<< std::endl;
		parent=adresse;
	}
	//FOURMI() impossible si reference
	//{
	//	std::cout<<"pas de parametres"<<"\n";
	//}
 
private:
	FOURMILIERE & parent;
};
 
class FOURMILIERE
{
public:
	FOURMILIERE()
	{
	}
 
	void naissance()
	{
		//S'il n'y a pas de virtualité, inutile d'utiliser l'allocation dynamique
		fourmis.push_back(FOURMI(*this));
 
		//Note: Si j'ai bien compris en C++11, la ligne au-dessus peut être remplacée par:
		fourmis.emplace_back(*this);
	}
 
private:
	std::vector<FOURMI> fourmis;
};    
 
int main()
{
	//FOURMI *fourmi=new FOURMI();
 
	FOURMILIERE *fourmiliere=new FOURMILIERE;
	fourmiliere->naissance();
	std::cout<<"fourmiliere "<<fourmiliere;
 
}

---

↓ Ça m'a l'air d'un gros fouillis dont je ne vois pas l'intérêt.

[MisterBobo]

Bonjour,

Si la classe fourmilière doit pouvoir instancier une fourmi elle doit avoir la visibilité sur la classe fourmi, les deux classes ne peuvent donc pas être indépendantes.
L'utilisation d'une interface (exemple ici : Geniteur_fourmi) permettrait en revanche de gérer la provenance de la fourmi (si différente que fourmilière). Je propose la solution bien qu'elle me paraisse "bancale", plus de données sur la structure encadrante permettrait d'en élaborer une bien meilleur (idem pour référence à la place de pointeur pour _parent).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
#include <stdlib.h>
#include <iostream>
#include <list>
#include <string>
 
class Geniteur_fourmi
{
public :
	virtual std::string dissocier_geniteur() = 0;
};
 
 
class Fourmi : public Geniteur_fourmi
{
private:
	Geniteur_fourmi &_parent;
public:
	Fourmi(Geniteur_fourmi *adr) : _parent(*adr) {};
	Fourmi() : _parent(*this) {}
	std::string dissocier_geniteur() {
		return (reinterpret_cast<int>(&(this->_parent)) != reinterpret_cast<int>(this)) ? _parent.dissocier_geniteur() : "moi-meme";
	}
	int get_parent() {
		return reinterpret_cast<int>(&(this->_parent));
	}
};
 
class Fourmiliere : public Geniteur_fourmi
{
private:
	std::list<Fourmi *>	_fourmis;
public:
	Fourmiliere() : _fourmis() {}
	Fourmi *naissance()
	{
		_fourmis.push_back(new Fourmi(this));
		return *_fourmis.rbegin();
	}
	std::string dissocier_geniteur() { return "une fourmiliere"; }
};
 
int main()
{
	Fourmiliere fourmil = Fourmiliere();
 
	Fourmi *fo_solitaire = new Fourmi();
	Fourmi *fo_fourmil = fourmil.naissance();
 
	std::cout << "Adresse du parent de fo solitaire : " << fo_solitaire->get_parent() << std::endl;
	std::cout << "Adresse du parent de fo fourmil : " << fo_fourmil->get_parent() << std::endl;
	std::cout << "Adresse du fourmil : " << reinterpret_cast<int>(&fourmil) << std::endl;
 
	std::list<Fourmi *> fourmis;
	fourmis.push_back(fo_solitaire);
	fourmis.push_back(fo_fourmil);
	for (std::list<Fourmi *>::const_iterator ci = fourmis.begin(); ci != fourmis.end(); ++ci)
	{
		std::cout << "J ai ete faite par " << (*ci)->dissocier_geniteur() << std::endl;
	}
	return 0;
}

[Médinoc]

Euh, que signifie le verbe "dissocier" pour toi?
Et pourquoi caster les pointeurs (et mal le faire) avant de les comparer?

[MisterBobo]

Avoir une information permettant de traiter différemment l'objet, pourquoi ?
Je compare les adresses des objets pour éviter que l'appel à dissocier_geniteur() ne parte en appel récursif infini puisque fourmi hérite de geniteur_fourmi. J'avais précisé que la solution était bancale.

[Médinoc]

Je compare les adresses des objets pour éviter que l'appel à dissocier_geniteur() ne parte en appel récursif infini puisque fourmi hérite de geniteur_fourmi. J'avais précisé que la solution était bancale.

Je ne t'ai pas demandé pourquoi tu les comparais, mais pourquoi tu les castais avant (tout en en perdant la moitié sur la plupart des architectures 64 bits).

[MisterBobo]

Parce que je ne compare pas des pointeurs mais des références et que je n'ai pas surchargé l'opérateur != pour Geniteur_fourmi.

[Médinoc]

Bon, puisque ça ne rentre apparemment pas dans ta tête:
Ceci:

Code C++ surcompliqué :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
	std::string dissocier_geniteur() {
		return (reinterpret_cast<int>(&(this->_parent)) != reinterpret_cast<int>(this)) ? _parent.dissocier_geniteur() : "moi-meme";
	}

Peut avantageusement être remplacé par ceci:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
	std::string dissocier_geniteur() {
		return ((&(this->_parent)) != this) ? _parent.dissocier_geniteur() : "moi-meme";
	}

Et au passage, elle devrait être const.

Et get_parent() devrait retourner une référence ou un intptr_t, pas un int. Et devrait aussi être const.

---

Et je n'ai toujours pas compris l'utilité de toute cette hiérarchie en premier lieu.

[MisterBobo]

Exact. Merci pour la correction.

Et la hiérarchie proposée permettait, à mon sens, de répondre au problème :

Si ce champ parent est destiné à être parent de plusieurs types d'objet, c'est adapté, on aura alors besoin d'un mécanisme pour pouvoir dissocier le type. Si le seul type possible de parent est FOURMILIERE, c'est pas grave de laisser en void, mais c'est pas propre et il faudra caster si nécessaire.

Dans ta solution du partais du postulat qu'une fourmis provenait forcément d'une fourmilière, ce qui ne semble pas être le souhait formulé.

une fourmi appartient ou non à une fourmilière. Une fourmilière possède ou non des fourmis, les 2 classes sont indépendantes.
Si je crée une fourmi depuis la classe fourmilière, je souhaites lui passer en paramètre l'adresse de l'instance de la fourmilière que je stockerais dans un champ parent.

De même il semblerait que les fourmilières ne soient pas les seules à pouvoir construire des fourmis.

[Médinoc]

Ah OK, compris maintenant.

[chrtophe]

Hola j'ai ouvert un débat.

J'ai rien compris à ton truc Medinoc, mais je bidouille plus qu'autre chose en C. explicit, je connais pas, je vais regarder ce point. Et il faut je bosse sur référence/pointeur.

Ce que j'ai fait fonctionne, mais je pense que c'est pas élégant, est-ce ce cependant à éviter ?

Une fourmi peut avoir une fourmilière en parent ou non. Quand elle est déclarée par naissance->fourmiliere(), méthode de la classe fourmiliere, lors de l'instanciation de celle-ci, la variable parent est fixée à l'adresse de la fourmiliere.

D'une fourmi, je peux donc connaitre sa fourmiliere, si celle-ci fait partie d'une fourmilière, dans mon cas ce n'est pas obligatoire. De la fourmilière, par ma liste chainée, je peux connaitre les fourmis de celle-ci.
Je considère qu'une fourmi fait partie d"une seule ou d'aucune fourmilière. Pour sortir une fourmi de sa fourmilière, il me faudra implémenter une méthode la retirant de ma liste chainée et mettre la variable parent de l'instance FOURMI concernée à NULL. Je pourrais aussi implémenter une méthode de changement de fourmilière si cette fonctionnalité sera possible. Dans l'exposé, je n'avais pas précisé si une fourmi pouvait changer de fourmiliere.

J'ai mis void non pas pour être parent de plusieurs types mais pour que le code compile car il n'y a aucune référence entre fourmi et fourmiliere. J'ai procédé comme cela car une fourmiliere peut ne contenir aucune fourmi et qu'une fourmi peut n'appartenir à aucune fourmiliere. Dans fourmiliere j'utilise fourmi, ça marche car fourmi est déclaré avant.

[ternel]

Une dépendance n'est pas mauvaise.

Ton texte parle de dépendance "une fourmi peut être née dans une fourmilière", ton code devrait retranscrire cela.

Par contre, si cela t’embête vraiment, tu peux mettre le type de la fourmilière comme template de la fourmi.
Ca me parait dommage, parce que tu devras déclarer des fourmi<fourmiliere>, mais la déclaration ne connaitra pas la fourmilière directement.


Et personnellement, je mettrai un constructeur avec la fourmillière parente en argument, pour ne pas avoir de fonction dans la fourmi pouvant modifier ce lien.


Une fourmi pouvant se lier à une seule fourmilière, au plus, il faut effectivement utiliser un pointeur.
Par contre, la fourmilière pouvant avoir plusieurs fourmis, tu pourrais avoir un vecteur de références ou un vecteur de fourmis.
Selon quelle partie du code doit posséder les fourmis (main, les fourmilières ou une autre classe)

[Médinoc]

Prédéclarer la classe suffit pour que Fourmi garde un pointeur vers Fourmilière:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class FOURMILIERE;
 
class FOURMI
{
    FOURMILIERE* parent;
};
 
class FOURMILIERE
{
    //(ta liste de fourmis ici)
};

Vu que la fourmi peut n'être dans aucune fourmilière, on utilise un pointeur.

[chrtophe]

Merci pour vos réponses