Liste de 2 classes diffentes sans STL

Version imprimable

20/09/2007, 19h04
Freygolow

Liste de 2 classes diffentes sans STL

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 :)

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

Code:

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:

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. ;)

20/09/2007, 20h36
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?
20/09/2007, 20h44
poukill

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

Question : et Boost, t'y as le droit ? :mrgreen:
20/09/2007, 20h48
Freygolow

Non pas le droit à boost ^^
20/09/2007, 20h57
poukill

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

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.
20/09/2007, 21h02
loufoque

Citation:

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> >

Code:

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... ;)

20/09/2007, 21h03
poukill

Citation:

Envoyé par loufoque

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é ! :aie:

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é!

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:

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;}
};

20/09/2007, 21h09
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 +
20/09/2007, 21h12
Freygolow

Ok merci, je vous tiens au courant :)

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:

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;
}