Discussion :

[ba1boun2]

Bonjour... ou plutôt bonsoir!

Je voudrai savoir si c'est possible de créer une liste dans laquelle j'ai des éléments de type classe mais aussi un élément de type liste. Si oui merci de me donner quelques indications sur la procédure a suivre.

Merci

[Klaim]

Je voudrai savoir si c'est possible de créer une liste dans laquelle j'ai des éléments de type classe mais aussi un élément de type liste.

Je pense que tu n'utilises pas les bons termes parceque ta phrase n'a pas beaucoup de sens. Est-ce que tu peux nous montrer ce que tu appelles "une liste"?

[ba1boun2]

En fait j'ai fait comme ça :

Code :

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

1
2
3
4
5
typedef struct L_dossier
{
	dossier dossier_n;
}un_dossier;
typedef list<un_dossier> Tdossier;

où dossier est une classe.

[Klaim]

Ok, alors dans ce cas ce que tu veux n'est pas directement possible, puisqu'une liste (std::list) ne peut contenir qu'un type. En revanche, tu peux faire quelque chose comme

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
 
// pas besoin de typedef en C++
struct un_dossier
{
	dossier dossier_n;
};
 
typedef std::list<un_dossier> Tdossier;
 
class node
{
public:
 
    // ces constructeurs vont rendre impossible d'avoir les deux pointeurs qui pointent sur quelque chose, c'est soit l'un, soit l'autre, soit aucun 
    node() : m_d( NULL ) , m_ld( NULL ) {}
    node( un_dossier* pd ) : m_d( pd ) , m_ld( NULL ) {}
    node( Tdossier* pld ) : m_d( NULL ) , m_ld( pld ) {}
    node( const node& other ) : m_d( other.m_d ) , m_ld( other.m_ld ) {}
 
    // helper
    bool isList() const { return ld != NULL; }
 
    //les accesseurs, on expose pas les membres pour  éviter que l'utilisateur ne change les pointeurs lui même
    un_dossier* d() const { return m_d; }
    Tdossier* ld() const { return m_ld; }
 
 
private:
    un_dossier* m_d;
    Tdossier* m_ld;
 
};
 
typedef std::list< node > special_list; // une liste qui peut "contenir" les deux
 
// utilisation
 
un_dossier* pd = new un_dossier();
Tdossier* pl = new Tdossier();
special_list.push_back( pd ); // pour ajouter un dossier
special_list.push_back( pl ); // pour ajouter une liste
 
const node& first_node = special_list.front();
if( first_node.isList() )
{
    Tdossier* first_list = first_node.ld();
}
else
{
    un_dossier* first_dossier = first_node.d();
}

Ou encore utiliser std::pair pour aller plus vite.

Mais de base clairement si tu te poses cette question c'est qu'il y a un problème dans ta conception. Quel est le problème que tu tentes de résoudre à l'origine?

[Invité]

Je voudrai savoir si c'est possible de créer une liste dans laquelle j'ai des éléments de type classe mais aussi un élément de type liste. Si oui merci de me donner quelques indications sur la procédure a suivre.

Dans la littérature, tu peux regarder le pattern "composite", qui correspond grosso modo à ce que tu veux faire. Il y en a plusieurs implémentations en C++, notamment pour traiter des problèmes de répertoires et de fichiers...


Francois

[3DArchi]

Bonjour,
Boost.Variant te propose une union et tu peux alors le mettre dans une liste de façon sûre.

[ba1boun2]

Klaim -> j'ai suivit tes indications, j'ai essayé ça :

Code :

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

1
2
3
4
5
6
7
8
9
const node& first_node = special_list.front();
if( first_node.isList() )
{
    Tdossier* first_list = first_node.ld();
}
else
{
    un_dossier* first_dossier = first_node.d();
}

Mais à la compilation, à la première ligne, il me dit :

expected primary-expression before ‘.’ token

[Klaim]

A quelle ligne?

[ba1boun2]

const node& first_node = special_list.front();