[Langage] Taille des pointeurs

Version imprimable

Citation:

Envoyé par Alp

dans ce lien, il écrit à un moment la classe de trait:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
template <typename T>
struct CallTraits
{
    template <typename U, bool Big> struct CallTraitsImpl;
 
    template <typename U>
    struct CallTraitsImpl<U, true>
    {
        typedef const U& Type;
    };
 
    template <typename U>
    struct CallTraitsImpl<U, false>
    {
        typedef U Type;
    };
 
    typedef typename CallTraitsImpl<T, (sizeof(T) > 8)>::Type ParamType;
};

une référence prend elle vraiment 8 octets ? (les pointeurs ne sont-ils pas des int ?)

26/11/2008, 11h48
Médinoc

Citation:

Envoyé par méphistopheles

une référence prend elle vraiment 8 octets ? (les pointeurs ne sont-ils pas des int ?)

Déjà, la taille devrait être écrite par rapport à un sizeof et non un nombre magique, mais ce cas est pour les problèmes de pointeur de membre: Un pointeur de membre peut être plus grand qu'un pointeur simple, notamment dans le cas de l'héritage multiple.
Voir cette page et les autres pages qu'elle référence.
26/11/2008, 16h51
méphistopheles

Citation:

Envoyé par Médinoc

Déjà, la taille devrait être écrite par rapport à un sizeof et non un nombre magique, mais ce cas est pour les problèmes de pointeur de membre: Un pointeur de membre peut être plus grand qu'un pointeur simple, notamment dans le cas de l'héritage multiple.
Voir cette page et les autres pages qu'elle référence.

j'avoue ne pas tout comprendre: qu'est-ce qu'un "adjustor" (une référence)? les références n'ont ellles pas de taille fixe ?
26/11/2008, 17h24
Médinoc

Eh bien, pas pour les "pointeurs de membres" (tu sais, les pointeurs avec une syntaxe bizarre), à cause de l'héritage multiple.
Je ne saurais pas expliquer plus en détail que dans cet article référencé par l'autre, par contre...
26/11/2008, 19h59
méphistopheles

Citation:

Envoyé par Médinoc

Eh bien, pas pour les "pointeurs de membres" (tu sais, les pointeurs avec une syntaxe bizarre), à cause de l'héritage multiple.
Je ne saurais pas expliquer plus en détail que dans cet article référencé par l'autre, par contre...

Je crains que ce ne soit l'article qui soit en cause, mais mon piètre niveau d'anglais (et de C++) en efft, je ne comprend pas pourquoi un pointeur à un membre serait plus gros qu'un pointeur externe par exemple. sinon, la taille "normale" d'un pointeur est bien 4octets non ?

Citation:

Envoyé par méphistopheles

Je crains que ce ne soit l'article qui soit en cause, mais mon piètre niveau d'anglais (et de C++) en efft, je ne comprend pas pourquoi un pointeur à un membre serait plus gros qu'un pointeur externe par exemple.

Je vais essayer de traduire.
En gros, tant qu'il n'y a pas d'héritage multiple, le pointeur n'est qu'un pointeur normal, aucun problème.
En effet, toutes les fonctions membres de la hiérarchie de classes utilisent le même pointeur this, aucun ajustement n'est nécessaire.

Maintenant, avec une classe qui dérive de deux autres:
Code:

1 2 3 4 class Base1 { int b1; void Base1Method(void); }; class Base2 { int b2; void Base2Method(void); }; class Derived : public Base1, Base2 { int d; void DerivedMethod(void); };
Ici, ça se complique, car le pointeur this passé aux méthodes de Base1 n'est pas le même que le pointeur this passé aux méthodes de Base2 : En gros:
Code:

1 2 3 4 Derived deriv; Base1 * pb1 = &deriv; Base2 * pb2 = &deriv; //Ici, pb1 et pb2 n'auront pas la même valeur.
C'est la présence de différents this qui fait qu'un pointeur simple ne suffit plus.
Si tu déclares un pointeur de ce type:
Code:

1 2 3 4 5 6 7 8 void (Derived::*ptrFonc)(void); switch(unTruc) { case 1: ptrFonc = &Derived::Base1Method; break; case 2: ptrFonc = &Derived::Base2Method; break; case 3: ptrFonc = &Derived::DerivedMethod; break; } (deriv.*ptrFonc)();
Comme on ne peut pas passer le même this à Base1Method et Base2Method, on est obligé de noter quelque part le décalage. Et on le note dans le pointeur de fonction membre, c'est pourquoi il prend huit octets au lieu de quatre.

Citation:

sinon, la taille "normale" d'un pointeur est bien 4octets non ?

Sur un système 32 bits, oui.

Citation:

Envoyé par méphistopheles

Je crains que ce ne soit l'article qui soit en cause, mais mon piètre niveau d'anglais (et de C++) en efft, je ne comprend pas pourquoi un pointeur à un membre serait plus gros qu'un pointeur externe par exemple. sinon, la taille "normale" d'un pointeur est bien 4octets non ?

Ce petit programme montre une partie des varietes de comportements d'un pointeur vers fonction membre. Si un simple pointeur devrait suffire dans les cas simple, ca ne va certainement pas deja si on lui assigne une fonction virtuelle et il faut encore plus d'info pour traiter les cas d'heritages multiples, virtuel ou non.

On pourrait vraisemblablement s'en sortir en generant des stubs -- qui ralentiraient les appels a travers les pfm.

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
#include <iostream>
 
struct c1 {
    void f() { std::cout << "c1::f()\n"; }
    virtual void g() { std::cout << "c1::g()\n"; }
};
 
struct c2: c1 {
    void f() { std::cout << "c2::f()\n"; }
    virtual void g() { std::cout << "c2::g()\n"; }
};
 
struct c3: virtual c1 {
    void f() { std::cout << "c3::f()\n"; }
    virtual void g() { std::cout << "c3::g()\n"; }
};
 
struct c4: virtual c1 {
    void f() { std::cout << "c4::f()\n"; }
};
 
struct c5: c3, c4 {
    void f() { std::cout << "c5::f()\n"; }
};
 
struct c6: c3, c4 {
    void f() { std::cout << "c6::f()\n"; }
    virtual void g() { std::cout << "c6::g()\n"; }
};
 
int main()
{
    c1 o1;
    c2 o2;
    c3 o3;
    c4 o4;
    c5 o5;
    c6 o6;
 
    c1& o2b = o2;
    c1& o3b = o3;
    c1& o4b = o4;
    c1& o5b = o5;
    c1& o6b = o6;
    c4& o54 = o5;
    c4& o64 = o6;
 
    void (c1::* fn)() = &c1::f;
 
    std::cout << "c1  "; (o1.*fn)();
    std::cout << "c2  "; (o2.*fn)();
    std::cout << "c3  "; (o3.*fn)();
    std::cout << "c4  "; (o4.*fn)();
    std::cout << "c5  "; (o5.*fn)();
    std::cout << "c6  "; (o6.*fn)();
    std::cout << "(c1&)c2  "; (o2b.*fn)();
    std::cout << "(c1&)c3  "; (o3b.*fn)();
    std::cout << "(c1&)c4  "; (o4b.*fn)();
    std::cout << "(c1&)c5  "; (o5b.*fn)();
    std::cout << "(c1&)c6  "; (o6b.*fn)();
    std::cout << "(c4&)c5  "; (o54.*fn)();
    std::cout << "(c4&)c6  "; (o64.*fn)();
 
    fn = &c1::g;
 
    std::cout << "c1  "; (o1.*fn)();
    std::cout << "c2  "; (o2.*fn)();
    std::cout << "c3  "; (o3.*fn)();
    std::cout << "c4  "; (o4.*fn)();
    std::cout << "c5  "; (o5.*fn)();
    std::cout << "c6  "; (o6.*fn)();
    std::cout << "(c1&)c2  "; (o2b.*fn)();
    std::cout << "(c1&)c3  "; (o3b.*fn)();
    std::cout << "(c1&)c4  "; (o4b.*fn)();
    std::cout << "(c1&)c5  "; (o5b.*fn)();
    std::cout << "(c1&)c6  "; (o6b.*fn)();
    std::cout << "(c4&)c5  "; (o54.*fn)();
    std::cout << "(c4&)c6  "; (o64.*fn)();
 
    return 0;
}

27/11/2008, 10h14
Médinoc

Ces problèmes pour les pointeurs de fonctions membres interdisent tout transtypage qui ne tient pas dans un static_cast. Si un transtypage est accepté par un static_cast, il n'y a pas de problème.