const return types, or lack thereof

[DynV]

From what I gather, functions return temporaries which don't need to be const (I assume making it const would use more processing) except for cases where returns are pointers or references.

I have no problem understanding why pointers would warrant such sensitivity. It's a common algorithm to move a pointer instead of calculating the new position from the start every-time. So just as easily as they can moved appropriately, they can be moved inappropriately.

Where I don't understand is the supposed need to make references const, I thought references were basically pointers that couldn't change once initiated and were required to be initiated. If something can't be change inherently, where's the need to repeat the requirement (and add processing) ?

Thanks

Sorry if I'm duplicating an issue, I couldn't find one alike with the search results I got from

Type: Posts; Keyword(s): return const; Forum = C++ Programming and child forums
Type: Posts; Keyword(s): return+const; Forum = C++ Programming and child forums
Type: Posts; Keyword(s): return AND const; Forum = C++ Programming and child forums

Note that choosing a differently using the Keyword drop-down (Search Entire Posts / Search Titles Only) display the same exact search characteristics (what I'm calling what's quoted).

[whiteflags]

I have no problem understanding why pointers would warrant such sensitivity. It's a common algorithm to move a pointer instead of calculating the new position from the start every-time. So just as easily as they can moved appropriately, they can be moved inappropriately.

And sometimes pointers and references refer to objects that shouldn't be changed at all, like literal strings.

const char *months[] = {"jan", "feb", "mar" /* ... */ };

Remove the const, create trouble....

The literal string is just one example. You will probably make your own constants in your programs, and create aliases for those constants.

[laserlight]

I have no problem understanding why pointers would warrant such sensitivity. It's a common algorithm to move a pointer instead of calculating the new position from the start every-time. So just as easily as they can moved appropriately, they can be moved inappropriately.

My guess is that most of the time when you see a const qualified pointer type as the return type of a function, the type is pointer to const rather than pointer that is const ("const pointer").

Where I don't understand is the supposed need to make references const, I thought references were basically pointers that couldn't change once initiated and were required to be initiated. If something can't be change inherently, where's the need to repeat the requirement (and add processing) ?

Ah, but "const reference" actually means "reference to const", not "reference that is const".

[DynV]

My guess is that most of the time when you see a const qualified pointer type as the return type of a function, the type is pointer to const rather than pointer that is const ("const pointer").

You're right and I usually detect it but that darn const-on-the-left-at-beggining-of-statements exception confused me! >

const T& operator*() const;

I always put const on the right.

And sometimes pointers and references refer to objects that shouldn't be changed at all, like literal strings.

I'm not sure what you mean but I assume my previous reply (in the same post) could be of use.

[Elkvis]

I assume making it const would use more processing

const is an entirely compile-time concept. if anything, it would require greater time to compile, but I seriously doubt it. the runtime performance would be identical, and possibly better in some cases.

[whiteflags]

Well I always thought I was one of the clearer folks on here. I can help you understand pointers and constness but I'm not sure if I can clarify my statement any further.

Pointers offer two levels of constness. One level, the lesser used in my opinion, relates to the pointer value.
>> char *const pch = right;
The const on the right of the star will prevent the pointer from moving, to use your words.
>> const char *pch = right;
This prevents code from changing the object that is being pointed to (called right here).

The levels of const mean different things, and if you combine both, you get a pointer that can only point to one thing, and dereference that one thing in a read only context.

References are much simpler. It is true that they don't move, but you can still use a reference to change an underlying object. Therefore, we can say that a reference may need to be declared const for purposes of const correctness. "const" is a qualifier keyword. Anything without it, can't be considered constant.

[Elkvis]

so to extend this:

const char *const pch = right;

would be a const pointer to const data, correct?

[laserlight]

would be a const pointer to const data, correct?

Yes.