[Langage] Taille des pointeurs

**méphistopheles** · 26/11/2008, 10h45

Envoyé par Alp

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

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

**Médinoc** · 26/11/2008, 11h48

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.

**méphistopheles** · 26/11/2008, 16h51

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 ?

**Médinoc** · 26/11/2008, 17h24

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

**méphistopheles** · 26/11/2008, 19h59

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 ?

**Médinoc** · 27/11/2008, 09h46

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 C++ :

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

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 C++ :

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

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 C++ :

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

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.

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

Sur un système 32 bits, oui.

**Jean-Marc.Bourguet** · 27/11/2008, 09h50

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 :

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

**Médinoc** · 27/11/2008, 10h14

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.

[Langage] Taille des pointeurs

Langage C++

Discussions similaires

Partager

Partager