Discussion :

[Krishna]

Bonjour à tous!
J'ai deux fonctions:

Code :

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

1
2
bool _A();
void _B(bool);

que j'utilise comme suit:

Code :

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

_B(_A());

Pour être sûr que mon programme ne bug pas dans son développement futur, j'ai besoin de m'assurer que ma fonction _B() n'accepte des arguments booléen uniquement qu'en provenance de _A();
Comment puis-je faire cela?

[loufoque]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
struct A_type;
 
A_type A_();
void B(A_type);
 
struct A_type
{
    bool value;
 
private:
    A_type(bool v) : value(v) {}
    friend A_type A_();
};

[Krishna]

Je vais tacher de trouver du détails dans un cours de cpp mais c'est exactement ce que je cherchais!

[Krishna]

Ah non..zut!!
En fait sur ce point tout va bien maintenant mais cela soulève une autre question:
Sachant que mes fonctions sont membre d'une classe, quel devrait être la bonne manière de déclarer mon "struct A_type;" ? (Comme membre de ma classe?)

[HanLee]

Tu veux pas regarder du côté de boost::function ? (qui sera bientôt std::function)

[Alp]

Ah non..zut!!
En fait sur ce point tout va bien maintenant mais cela soulève une autre question:
Sachant que mes fonctions sont membre d'une classe, quel devrait être la bonne manière de déclarer mon "struct A_type;" ? (Comme membre de ma classe?)

Tu peux très bien déclarer des classes/structures dans d'autres classes/structures

[koala01]

Salut,

Tu peux très bien déclarer des classes/structures dans d'autres classes/structures

Cela s'appelle "les classes (ou structures) imbriquées, et cela peut ressembler à

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
class B
{
    public:
        /* le fait que A soit accessible depuis l'extérieur dépend de
         * l'accessibilité dans laquelle elle est déclarée, ici, elle sera
         * accessible sous la forme de B::A
         /*
        struct A
        {
            /* un constructeur est toujours possible 
             * mais rendons le explicit pour s'assurer de forcer la création
             * d'une variable de type A
             */
            explicit A(bool value):value(value){}
            bool value;
        };
        B();
        ~B();
        void foo(A param)
        {
            if(a.value)
            {
                /*...*/
            }
            else
            {
                /*...*/
            }
        }
};

Le tout serait utilisé sous les formes proches de

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
 
int main()
{
    /* une variable de type A */
    B::A myA(true);
    /* une variable de type B */
    B myB;
    myB.foo(myA);
    /* aurrait put etre écrit sous la forme de */
    /* une autre variable de type B */
    B myOtherB;
    myOtherB.fo(B::A(true));
    return 0
 
}