CODEWITHSUNDEEP
c++c
vehomzzz
vehomzzz

Reputation: 44578

Why is a type qualifier on a return type meaningless?

Say I have this example:

char const * const
foo( ){
   /* which is initialized to const char * const */
   return str;
}

What is the right way to do it to avoid the compiler warning "type qualifier on return type is meaningless"?

Upvotes: 25

Views: 31776

Answers (3)

j-vasil
j-vasil

Reputation: 149

None of the previous answers actually answer the "right way to do it" part of the question.

I believe that the answer to this is:

char const * foo( ){

which says you are returning a pointer a constant character.

Upvotes: 2

Johannes Schaub - litb
Johannes Schaub - litb

Reputation: 506955

The way you wrote it, it was saying "the returned pointer value is const". But non-class type rvalues are not modifiable (inherited from C), and thus the Standard says non-class type rvalues are never const-qualified (right-most const was ignored even tho specified by you) since the const would be kinda redundant. One doesn't write it - example:

  int f();
  int main() { f() = 0; } // error anyway!

  // const redundant. returned expression still has type "int", even though the 
  // function-type of g remains "int const()" (potential confusion!)
  int const g();

Notice that for the type of "g", the const is significant, but for rvalue expressions generated from type int const the const is ignored. So the following is an error:

  int const f();
  int f() { } // different return type but same parameters

There is no way known to me you could observe the "const" other than getting at the type of "g" itself (and passing &f to a template and deduce its type, for example). Finally notice that "char const" and "const char" signify the same type. I recommend you to settle with one notion and using that throughout the code.

Upvotes: 26

pmg
pmg

Reputation: 108978

In C, because function return values, and qualifying values is meaningless.
It may be different in C++, check other answers.

const int i = (const int)42; /* meaningless, the 42 is never gonna change */
int const foo(void); /* meaningless, the value returned from foo is never gonna change */

Only objects can be meaningfully qualified.

const int *ip = (const int *)&errno; /* ok, `ip` points to an object qualified with `const` */
const char *foo(void); /* ok, `foo()` returns a pointer to a qualified object */

Upvotes: 6

Related Questions