Const member function vs const return type

Question

In D I can specify const functions, like in c++:

struct Person {
    string name;

    // these two are the same?
    const string getConstName() { return name; }     
    string getConstName2() const { return name; }   
}

It seems that the above two are the same meaning. Is it true?

If so how can I return a const string rather than define a const function?

Answer 1

The two are identical. Function attributes can go on either side of a function. e.g.

pure Bar foo() {...}

and

Bar foo() pure {...}

are identical. The same goes for pure, nothrow, const, etc. This is probably fine for most attributes, but it becomes quite annoying when const, immutable, or inout is involved, because they can all affect the return type. In order for those attributes to affect the return type, parens must be used. e.g.

const(Bar) foo() {...}

returns a const Bar, whereas

Bar foo const {...}

and

const Bar foo() {...}

return a mutable Bar, but the member function itself is const. In most cases what you want is probably either

Bar foo() {...}

or

const(Bar) foo() const {...}

since it's frequently the case that having a const member function forces you to return const (particularly if you're returning a member variable), but you can have any combination of const between the member function and its return type just so long as it works with what the function is doing (e.g. returning a mutable reference to a member variable doesn't work from a const function).

Now personally, I wish that putting const on the left-hand side were illegal, particularly when the excuse that all function attributes can go on either side of the function isn't really true anyway (e.g. static, public, and private don't seem to be able to go on the right-hand side), but unfortunately, that's the way it is at this point, and I doubt that it's going to change, because no one has been able to convince Walter Bright that it's a bad idea to let const go on the left.

However, it is generally considered bad practice to put const, immutable, or inout on the left-hand side of the function unless they're using parens and thus affect the return type, precisely because if they're on the left without parens, you immediately have to question whether the programmer who did it meant to modify the function or the return type. So, allowing it on the left is pretty pointless (aside perhaps for generic code, but it's still not worth allowing it IMHO).