Why is a type qualifier on a return type meaningless?

Say I have this example:

char const * const
开发者_如何学Pythonfoo( ){
   /* 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"?

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.

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 */

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.