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.