Why const can disappear at QMap::value(...)

[ChrisW67]

So I can use MyObject * object_one = myMap->value(1); and it is completely valid, although value() returns MyObject const * object_one (which is a copy of the value in the map).

In your example the QMap<Key,T> template works out like this

QMap<int, MyObject*> map;
//   ^    ^
//   |    +-- T == "MyObject*"
//   |
//   +-- Key == "int"

QMap<int, MyObject*> map;
//   ^    ^
//   |    +-- T == "MyObject*"
//   |
//   +-- Key == "int"

To copy to clipboard, switch view to plain text mode 

The function QMap::value() returns a "const T", that is, "const MyObject*" (constant pointer-to-obj) not "MyObject const *" (pointer-to-const-obj) . In assigning that return value to a pointer variable you make a copy of it, which may or may not be const.

Have a look at the variations in here:

#include <QCoreApplication>
#include <QMap>
 
class MyObject {
public:
    void constFunc() const { }
    void nonConstFunct() { }
};
 
int main(int argc, char **argv) {
    QCoreApplication app(argc, argv);
 
    MyObject       *a = new MyObject;
    MyObject const *b = new MyObject;
 
    QMap<int, MyObject *> map1;
    map1.insert(0, a); // ok
//    map1.insert(1, b); // error, cannot put pointer-to-const in map
 
    MyObject       *c = map1.value(0); // ok
    MyObject const *d = map1.value(0); // ok
    c->nonConstFunct(); // ok
//    d->nonConstFunct(); // error, we promised d pointed to a const object
 
    // You can have a map contain pointer-to-const-object
    QMap<int, MyObject const *> map2;
    map2.insert(0, a); // ok
    map2.insert(1, b); // ok
 
//    c = map2.value(0); // error, map cannot put "MyObject const *" into a non-const pointer var
    d = map2.value(1); // ok
 
    d->constFunc(); // ok, pointer-to-const and const function
//    d->nonConstFunct(); // error, pointer-to-const and non-const function
 
    delete a;
    delete b;
 
    return 0;
}

#include <QCoreApplication>
#include <QMap>

class MyObject {
public:
    void constFunc() const { }
    void nonConstFunct() { }
};

int main(int argc, char **argv) {
    QCoreApplication app(argc, argv);

    MyObject       *a = new MyObject;
    MyObject const *b = new MyObject;

    QMap<int, MyObject *> map1;
    map1.insert(0, a); // ok
//    map1.insert(1, b); // error, cannot put pointer-to-const in map

    MyObject       *c = map1.value(0); // ok
    MyObject const *d = map1.value(0); // ok
    c->nonConstFunct(); // ok
//    d->nonConstFunct(); // error, we promised d pointed to a const object

    // You can have a map contain pointer-to-const-object
    QMap<int, MyObject const *> map2;
    map2.insert(0, a); // ok
    map2.insert(1, b); // ok

//    c = map2.value(0); // error, map cannot put "MyObject const *" into a non-const pointer var
    d = map2.value(1); // ok

    d->constFunc(); // ok, pointer-to-const and const function
//    d->nonConstFunct(); // error, pointer-to-const and non-const function

    delete a;
    delete b;

    return 0;
}

To copy to clipboard, switch view to plain text mode 

[QtCrawler]

Ok thanks for your reply!

I thought const MyObject* is the same as MyObject const *, so a pointer to a const MyObject. (I read it from right to left.)

[Vikram.Saralaya]

"const MyObject*" (constant pointer-to-obj) not "MyObject const *" (pointer-to-const-obj)

@ChrisW67 I don't think so..

If I am not wrong, "MyObject * const" is a constant pointer-to-obj. The two things you mentioned are both pointers to const-obj.

[yeye_olive]

@ChrisW67 I don't think so..

If I am not wrong, "MyObject * const" is a constant pointer-to-obj. The two things you mentioned are both pointers to const-obj.

Indeed. ChrisW67 textually substituted "T" with "MyObject*" is his otherwise perfectly exact explanation, but I am sure he meant a semantic substitution: "immutable T" -> "immutable pointer to (mutable) MyObject" aka "MyObject *const".

[d_stranz]

Even after 25+ years of C++ coding, this is one aspect that continues to confuse me. And then there are the versions with two const declarations "const MyObject const *" or whatever. Thank god for google.

[ChrisW67]

It is a strange person that does not have to think twice (i wrote the code to check myself). As yeye_olive points out, even my explanation is a little imprecise. To be clear, value() returns type MyObject* const and not const MyObject* (more clearly written MyObject const *) as a naive text substitution interpretation of templates might lead you to think.

In my defence, it was a long week

[QtCrawler]

Thank you guys.
It's great to discuss such topics with you.
Thank god for QtC

[yeye_olive]

Even after 25+ years of C++ coding, this is one aspect that continues to confuse me. And then there are the versions with two const declarations "const MyObject const *" or whatever. Thank god for google.

C/C++ is quite liberal with the placement of the "const" qualifier in a declarator. IMHO it is a shame that the ambiguous form "const T *" be so prevalent. I tend to consistently place "const" after the type it qualifies, like * and &, which eliminates the ambiguous forms. All I have to do is read the declaration from right to left:
T const: constant T
T const *: pointer to constant T
T * const: constant pointer to T
T const * const: constant pointer to constant T

If you ever are in doubt about a declaration, check out the excellent cdecl.org.