Pointeur constant sur objet constant

**escafr** · 30/06/2008, 16h20

Bonjour à tous j'ai joué avec les const pour voir tout ce qu'on pouvait faire avec.

Voici mon programme de test:

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
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
// ConstPointerTest.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <string>
#include <iostream>
#include <map>

class A{
public:
    A (std::string aName) {name = aName;}
    void setName(std::string aName) {name = aName;}
    std::string getName() const {return name;}
private:
    std::string name;
};

class B{
public:

    //You can modify the object and the pointer.
    void addpA(A * aA) {
        std::cout << "A * aA" << std::endl;
        aA->setName("A * aA");
        pAs.insert(std::make_pair(aA->getName(), aA));
        cpAs.insert(std::make_pair(aA->getName(), aA));
        pcAs.insert(std::make_pair(aA->getName(), aA));
        pAcs.insert(std::make_pair(aA->getName(), aA));
        cpAcs.insert(std::make_pair(aA->getName(), aA));
        aA = NULL;
    }

    // Constant pointed object
    void addcpA(const A * aA) {
        std::cout << "const A * aA" << std::endl;
        //aA->setName("const A * aA"); 'A::setName' : cannot convert 'this' pointer from 'const A' to 'A &'
        //pAs.insert(std::make_pair(aA->getName(), aA)); cannot convert from 'const A *const ' to 'A *'
        cpAs.insert(std::make_pair(aA->getName(), aA));
        pcAs.insert(std::make_pair(aA->getName(), aA));
        // pAcs.insert(std::make_pair(aA->getName(), aA)); cannot convert from 'const A *const ' to 'A *const '
        cpAcs.insert(std::make_pair(aA->getName(), aA));
        aA = NULL;
    }

    // Same as addcpA
    void addpcA(A const * aA) {
        std::cout << "A const * aA" << std::endl;
        //aA->setName("A const * aA"); 'A::setName' : cannot convert 'this' pointer from 'const A' to 'A &'
        //pAs.insert(std::make_pair(aA->getName(), aA)); cannot convert from 'const A *const ' to 'A *const 
        cpAs.insert(std::make_pair(aA->getName(), aA));
        pcAs.insert(std::make_pair(aA->getName(), aA));
        //pAcs.insert(std::make_pair(aA->getName(), aA)); cannot convert from 'const A *const ' to 'A *const '
        cpAcs.insert(std::make_pair(aA->getName(), aA));
        aA = NULL;
    }

    // Constant pointer, we can modify the object
    void addpAc(A * const aA ) {
        std::cout << "A * const aA" << std::endl;
        aA->setName("A * const aA");
        pAs.insert(std::make_pair(aA->getName(), aA));
        cpAs.insert(std::make_pair(aA->getName(), aA));
        pcAs.insert(std::make_pair(aA->getName(), aA));
        pAcs.insert(std::make_pair(aA->getName(), aA));
        cpAcs.insert(std::make_pair(aA->getName(), aA));
        //aA = NULL; 'aA' : you cannot assign to a variable that is const
    }

    // The total constant pointer and constant object.
    void addcpAc(const A * const aA) {
        std::cout << "const A * const aA" << std::endl;
        //aA->setName("const A * const aA"); cannot convert 'this' pointer from 'const A' to 'A &'
        //pAs.insert(std::make_pair(aA->getName(), aA));  cannot convert from 'const A *const ' to 'A *'
        cpAs.insert(std::make_pair(aA->getName(), aA)); // Why does it work? You loose the const pointer
        pcAs.insert(std::make_pair(aA->getName(), aA)); // Why does it work? You loose the const pointer
        //pAcs.insert(std::make_pair(aA->getName(), aA)); cannot convert from 'const A *const ' to 'A *const '
        cpAcs.insert(std::make_pair(aA->getName(), aA));
        //aA = NULL; 'aA' : you cannot assign to a variable that is const
    }

private:
    A* a;
    std::map < std::string, A* > pAs;
    std::map < std::string, const A* > cpAs;
    std::map < std::string, A const * > pcAs;
    std::map < std::string, A* const> pAcs;
    std::map < std::string, const A* const> cpAcs;
};

int _tmain(int argc, _TCHAR* argv[])
{
    B b;

    A* pA = new A("pA");
    const A* cpA = new A("cpA");
    A const * pcA = new A("pcA");
    A * const pAc = new A("pAc");
    const A * const cpAc = new A("cpAc");

    std::cout << "Start" << std::endl << pA->getName() << std::endl << cpA->getName() << std::endl<< pcA->getName() << std::endl << pAc->getName() << std::endl << cpAc->getName() << std::endl;
    std::cout << "// pA" << std::endl;
    // pA
    b.addpA(pA);
    b.addcpA(pA);
    b.addpcA(pA);
    b.addpAc(pA);
    b.addcpAc(pA);

    std::cout << "// cpA" << std::endl;
    // cpA
    //b.addpA(cpA); //cannot convert parameter 1 from 'const A *' to 'A *'
    b.addcpA(cpA);
    b.addpcA(cpA);
    //b.addpAc(cpA); //cannot convert parameter 1 from 'const A *' to 'A *const '
    b.addcpAc(cpA);

    std::cout << "// pcA" << std::endl;
    //pcA
    //b.addpA(pcA); //cannot convert parameter 1 from 'const A *' to 'A *'
    b.addcpA(pcA);
    b.addpcA(pcA);
    //b.addpAc(pcA); // cannot convert parameter 1 from 'const A *' to 'A *const '
    b.addcpAc(pcA);

    std::cout << "// pAc" << std::endl;
    //pAc
    b.addpA(pAc);
    b.addcpA(pAc);
    b.addpcA(pAc);
    b.addpAc(pAc);
    b.addcpAc(pAc);

    std::cout << "End" << std::endl << pA->getName() << std::endl << cpA->getName() << std::endl<< pcA->getName() << std::endl << pAc->getName() << std::endl << cpAc->getName() << std::endl;

    int i;
    std::cin >> i;

	return 0;
}

le resultat:

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
 
//// Result:
//            Start
//            pA
//            cpA
//            pcA
//            pAc
//            cpAc
 
//            // pA
//            A * aA
//            const A * aA
//            A const * aA
//            A * const aA
//            const A * const aA
 
//            // cpA
//            const A * aA
//            A const * aA
//            const A * const aA
 
//            // pcA
//            const A * aA
//            A const * aA
//            const A * const aA
 
//            // pAc
//            A * aA
//            const A * aA
//            A const * aA
//            A * const aA
//            const A * const aA
 
//            End
//            A * const aA
//            cpA
//            pcA
//            A * const aA
//            cpAc

ma question se porte sur la partie du code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
    // The total constant pointer and constant object.
    void addcpAc(const A * const aA) {
        std::cout << "const A * const aA" << std::endl;
        //aA->setName("const A * const aA"); cannot convert 'this' pointer from 'const A' to 'A &'
        //pAs.insert(std::make_pair(aA->getName(), aA));  cannot convert from 'const A *const ' to 'A *'
        cpAs.insert(std::make_pair(aA->getName(), aA)); // Why does it work? You loose the const pointer
        pcAs.insert(std::make_pair(aA->getName(), aA)); // Why does it work? You loose the const pointer
        //pAcs.insert(std::make_pair(aA->getName(), aA)); cannot convert from 'const A *const ' to 'A *const '
        cpAcs.insert(std::make_pair(aA->getName(), aA));
        //aA = NULL; 'aA' : you cannot assign to a variable that is const
    }

Pourquoi ces deux lignes marchent:

Code :

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

1
2
 cpAs.insert(std::make_pair(aA->getName(), aA)); // Why does it work? You loose the const pointer
        pcAs.insert(std::make_pair(aA->getName(), aA)); // Why does it work? You loose the const pointer

On perd l'information du pointeur constant en autorisant ceci non?

Pour info, je ne l'ai teste que sur visual studio 2005.

**Médinoc** · 30/06/2008, 16h28

Non, on ne perd aucune information.

C'est l'équivalent strict de ceci:

Code :

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

1
2
3
4
5
6
7
8
9
void UneFonction(UnType const * p);
void UneFonctionRef(UnType const * const & rp);
 
void UneAutreFonction(void)
{
	Untype const * const unPointeur = 0;
	UneFonction(unPointeur);
	UneFonctionRef(unPointeur);
}

Dans ce code, la fonction UneFonction reçoit une copie non-constante de p.
Et la fonction UneFoncionRef reçoit une référence const vers p.

**escafr** · 30/06/2008, 16h39

Hum, ok c'est l equivalent mais ca l'explique pas forcement

**Médinoc** · 30/06/2008, 16h57

Ben si: Le passage se fait par copie, et la copie n'a pas besoin d'être aussi constante que l'original:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
const int a = 42;
int b = a; //copie
 
int * const p = &b;
int * p2 = p; //copie
 
int const * const pc = &a;
int const * pc2 = pc; //copie
 
//Par contre, ceci ne marche pas, car c'est l'objet pointé qui est const:
int * p3 = pc2; //Erreur: perte de const.

**escafr** · 30/06/2008, 17h23

ok merci bcp.

Pointeur constant sur objet constant

C++

Vue hybride

Discussions similaires

Partager

Partager