struct X {};

X const f();

template <class T>
    int g(T &);

int main()
{
    sizeof g(f());
}

14.8.2.1/1
Template argument deduction is done by comparing each function template parameter type (call it P) with the type of the corresponding argument of the call (call it A) as described below

14.8.2.1/2
If P is not a reference type:
...
— If A is a cv-qualified type, the top level cv-qualifiers of A’s type are ignored for type deduction.

const char* const GetName();
const int GetNumber();

char const* const GetName();
int const GetNumber();

int f1();
int const f2();
 
template <class T>
    void g(T &);
int g(double);

int main()
{
    sizeof g(f1());
    sizeof g(f2()); // VC++ & GNU C++: T is deduced to be 'const int'
}

int f1() { return 0; }
int const f2() { return 0; }

int main()
{
    int (&r1)() = f1;
    int (&r2)() = f2; // ill-formed
}

CS>>const char* function();
I>

CS>>collection coll;
CS>>coll[2].mutating_method(); 
I>

I>void f(value v)
I>{
I>    v.mutating_method();
I>}

I>collection coll;
I>f(coll[2]);
I>

void f(value v)

void f(value& v)

collection coll;
f(coll[2]);

void f(const value& v)

Избегайте реализации абстракции массива посредством массивов в стиле C, арифметики указателей и примитивов управления памятью. Использование vector и string не только сделает проще вашу жизнь, но и позволит написать более безопасную и масштабируемую программу.

class Device
{
...
private:    
    char m_name[20];
public:
...
    const char* const GetName() const;
}

Device d("name1");
strcpy((char*)d.GetName(),"name2");

Достаточно возвращать из функции char const*...

The given scanner does not address any input stream encoding problems.

const T function();

CS>const T function();
CS>

Альтернативная форма позиции const более последовательна:

char const* const GetName();
int const GetNumber();

Означает совершенно то же самое, но избыточный const находится справа в обоих случаях, что позволяет сформулировать простое правило: "const непосредственно перед именем функции избыточен".

T const function();

B>T const function();
B>

T const function();
const T function();

CS>T const function();
CS>const T function();

CS>T const function();
CS>const T function();
CS>

struct I {};

typedef I& RInt;

const RInt f1();
RInt const f2();

int main()
{
   I& ri = f1();
   return 0;
}

Comeau:
"ComeauTest.c", line 9: warning: type qualifiers are meaningless in this declaration
const RInt f1();
^

"ComeauTest.c", line 10: warning: type qualifiers are meaningless in this
declaration
RInt const f2();
^

    ++C(f());

CS>>T const function();
CS>>const T function();
I>

const char* function();

class collection
{
  ...
  const value operator[](int i) const { return get_item_at(i); } 
}

collection coll;
coll[2].mutating_method();

collection coll;
coll[2].const_method();

CS>const char* function();

CS>class collection
CS>{
CS>  ...
CS>  const value operator[](int i) const { return get_item_at(i); } 
CS>}

CS>collection coll;
CS>coll[2].mutating_method();

void f(value v)
{
    v.mutating_method();
}

collection coll;
f(coll[2]);

CS>>>T const function();
CS>>>const T function();
I>>

3.10/5
The result of calling a function that does not return a reference is an rvalue.

3.10/9
Class rvalues can have cv-qualified types; non-class rvalues always have cv-unqualified types.

CS>>>const char* function();

CS>void f(value v)

1.3.1 argument
an expression in the comma-separated list bounded by the parentheses in a function call expression, a sequence of preprocessing tokens in the comma-separated list bounded by the parentheses in a function-like macro invocation, the operand of throw, or an expression, type-id or template-name in the comma-separated list bounded by the angle brackets in a template instantiation. Also known as an actual argument or actual parameter.

3.10 Lvalues and rvalues
1 Every expression is either an lvalue or an rvalue.

template-declaration:
  export_opt template < template-parameter-list > declaration
                                                      \--- 'void g(T& x)'

template-parameter-list:
  template-parameter
  template-parameter-list , template-parameter

template<class T> 
//             \---Template parameter
void g(T& x);
//        \-- Function parameter of a function template
//...
//
g<int>(v); // гипотетический вызов
//  \-------- Template argument

Note: if T is a non-class type that is cv-qualified, the cv-qualifiers are ignored when determining the type of the resulting rvalue (3.10).

int &f();
template <class T>
    char g(T);

int main()
{
    sizeof g(f());
}

If an expression initially has the type “reference to T” (8.3.2, 8.5.3), the type is adjusted to “T” prior to any further analysis, the expression designates the object or function denoted by the reference, and the expression is an lvalue.

The result of calling a function that does not return a reference is an rvalue.