Discussion :

[Freygolow]

Bonsoir,

Depuis plusieurs jours, j'essai de creer une listes de 2 classes differentes.
Par exemple, j'ai creer une class A et une class B et je veux faire une liste: A-B-A-B-A-B

Cela est-il possible? je pense que oui ^^
Pouvez vous m'aider s'il vous plait?

Sinon une liste permet-elle d'avoir plusieurs chemin?

Ex : A-B-A-B-A-B
.............|
............ C-A-C

Merci

[poukill]

Oui c'est possible... à condition que A et B aient la même classe mère!

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
class Mother
{
     public :
     Mother() {} 
     virtual ~Mother() {}
 
     virtual void doSomething() = 0;
};
 
class A : public Mother
{
    public:
    A() {}
 
    virtual void doSomething() { std::cout << "Je suis A" << std::endl; }
};
 
class B : public Mother
{
    public:
    B() {}
 
    virtual void doSomething() { std::cout << "Je suis B" << std::endl;}
};

Avec ça tu peux faire:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
std::list<Mother*> multi_list;
A* a = new A();
B* b = new B();
multi_list.insert(a);
multi_list.insert(b);
 
std::list<Mother*>::const_iterator iter = multi_list.begin();
 
for (; iter != multi_list.end(); ++iter)
{
    iter->doSomething();
}
delete a;
delete b;

C'est grâce au polymorphisme.

[Freygolow]

Merci d'avoir repondu

Cela tombe bien car mes Classes A et B descendent d'une classe de base

Donc le premier carré de code j'ai compris mais le deuxieme je n'est jamais vu ça. Si ça utilise la bibliotheque STL, he ne dois pas l'utilisé

Pour faire la liste, il faudrait creer un classe liste avec comme membre liste* suivant je pense non?

[poukill]

Ah désolé j'avais pas vu sans la STL... De quelle partie du C++ tu te prives !

Question : et Boost, t'y as le droit ?

[Freygolow]

Non pas le droit à boost ^^

[poukill]

Pffffffffff
On m'a toujours dit : "Un bon ouvrier a de bons outils" !

Plus sérieusement, toute la première partie (le polymorphisme) c'est le noyau.
Après tu n'as plus qu'a implémenter ta liste, ou ton vecteur... avec un tableau classique par exemple.

[loufoque]

Par exemple, j'ai creer une class A et une class B et je veux faire une liste: A-B-A-B-A-B

std::list<std::pair<A, B> >

[poukill]

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
#include <iostream>
 
class Mother
{
     public :
     Mother() {} 
     virtual ~Mother() {}
 
     virtual void doSomething() = 0;
};
 
class A : public Mother
{
    public:
    A() {}
 
    virtual void doSomething() { std::cout << "Je suis A" << std::endl; }
};
 
class B : public Mother
{
    public:
    B() {}
 
    virtual void doSomething() { std::cout << "Je suis B" << std::endl;}
};
 
int main()
{
	Mother ** vect = new Mother* [2];
 
	A* a = new A();
	B* b = new B();
	vect[0] = a;
	vect[1] = b;
 
	for (int i = 0; i < 2; i++)
	{
		vect[i]->doSomething();
	}
 
	delete a;
	delete b;
 
	return 0;
}

Voilà un exemple ! C'est moins bien qu'avec la STL mais bon...

[poukill]

std::list<std::pair<A, B> >

sans la STL ...
Eh oui, c'est plus chiant !
Remarque avec ton idée, y'a même pas besoin du polymorphisme...
J'y avais même pas pensé !

D'un autre côté, on perd un peu la relation d'ordre A B A B, puisque A et B sont mis sur un pied d'égalité!

[Freygolow]

Voila je vous montre comment je suis dans le brouillard concernant les listes. Voila comment je vois comment faire une liste mais cela ne marche pas. Il y a sans doute quelque chose que je n'es pas compris.

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
 
 
class liste
{
friend class Mother;
 
A *suivant;
B *suivant;
}
 
class Mother
{
     public :
     Mother() {} 
     virtual ~Mother() {}
 
     virtual void doSomething() = 0;
};
 
class A : public Mother
{
    public:
    A() {}
 
    virtual void doSomething() { std::cout << "Je suis A" << std::endl; }
};
 
class B : public Mother
{
    public:
    B() {}
 
    virtual void doSomething() { std::cout << "Je suis B" << std::endl;}
};

[poukill]

Non, si tu veux faire une liste chainée, il faut que tu fasses un pointeur sur un Mother pour le noeud suivant...
Je te laisse un peu réfléchir...


A +

[Freygolow]

Ok merci, je vous tiens au courant

[poukill]

Voici un exemple de code "simple" avec seulement la fonction insert pour ajouter un élément et l'opérateur[] pour accéder aux éléments.

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include <iostream>
#include <limits>
 
class Mother
{
    public :
    Mother() {} 
	virtual ~Mother() {}
 
    virtual void doSomething() = 0;
 
	Mother* next;
	Mother* previous;
	int numero;
};
 
class List
{
public:
	List() :pos(-1), current(NULL) {}
	~List() {}
	void insert(Mother * elem);
 
	Mother* operator[] (int i);
 
	static int numero;
 
private:
	Mother * current;
	int pos;
};
 
int List::numero = 0;
 
Mother* List::operator [](int i)
{
	Mother * obj = current;
	int pos_cur = pos;
 
	while ( i != pos_cur )
	{
		if (i > pos)
		{
			obj = obj->next;
			pos_cur++;
		}
 
		if (i < pos)
		{
			obj = obj->previous;
			pos_cur--;
		}
	}
 
	return obj;
}
 
void List::insert(Mother* elem)
{
	numero++;
	if (current == NULL)
	{
		current = elem;
		current->previous = NULL;
		current->numero = List::numero;
	}
	else
	{
		elem->previous = current;
		current->next = elem;
		current = elem; //on met à jour
		current->numero = List::numero;
	}
	pos++;
}
 
class A : public Mother
{
	public:
	A() {}
 
	virtual void doSomething() { std::cout << "Je suis A : " << numero << std::endl; }
};
 
class B : public Mother
{
    public:
    B() {}
 
	virtual void doSomething() { std::cout << "Je suis B : " << numero <<  std::endl;}
};
 
 
 
 
 
int main()
{
	List list;
	A* a = new A();
	B* b = new B();
	B* b2 = new B();
	A* a2 = new A();
 
	list.insert(a);
	list.insert(b);
	list.insert(a2);
	list.insert(b2);
 
	list[0]->doSomething();
	list[1]->doSomething();
	list[2]->doSomething();
	list[3]->doSomething();
 
	delete a;
	delete b;
        delete a2;
	delete b2;
 
	std::cout << "Appuyez sur entrée pour continuer...";
	std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );
 
	return 0;
}