const char* str = "Эта строка константна?"

void f(const char*& p)
{
        // p - ссылка на неконстантный указатель на константную строку...
    p = str;
}

void g()
{
        char* s;
        f(s); // Если это допускается, то все очень плохо
        strcpy(s, "Фигушки!");
}

class CFoo
{
 ...
 void operator <<(???) {???}
 ...
};
CFoo f;
f << "Число" << 5 ;

А>class CFoo
А>{
А> ...
А> void operator <<(???) {???}
А> ...
А>};
А>CFoo f;
А>f << "Число" << 5 ;
А>

class CFoo
{
 ...
 CFoo & operator << (int x) { ... return *this; }
 CFoo & operator << (char *x) { ... return *this; }
 CFoo & operator << (const char *x) { ... return *this; }
 ...
};
CFoo f;
f << "Число" << 5 ;

Ш>>class CFoo
Ш>>{
Ш>> ...
Ш>> CFoo & operator << (int x) { ... return *this; }
Ш>> CFoo & operator << (char *x) { ... return *this; }
Ш>> CFoo & operator << (const char *x) { ... return *this; }
Ш>> ...
Ш>>};
Ш>>

ПК>А зачем обе версии: и operator << (char *x), и operator << (const char *x)?

template <class T>
CFoo & operator << (const T &x) { ... return *this; }

ПК>>А зачем обе версии: и operator << (char *x), и operator << (const char *x)?

Ш>template <class T>
Ш>CFoo & operator << (const T &x) { ... return *this; }
Ш>

#include <iostream>

class CFoo
{
public:
 CFoo & operator << (int x) {
   std::cout << "operator << (int)" << std::endl;
   return *this; }

 CFoo & operator << (const char *x)  {
   std::cout << "operator << (const char *)" << std::endl;
   return *this; }

 template<class T>
 CFoo & operator << (const T&) {
   std::cout << "operator << (const T&)" << std::endl;
   return *this; }
};

int main()
{
  CFoo f;
  f << "Число" << 5 ;

  char* c = 0;
  f << c;
}

operator << (const char *)
operator << (int)
operator << (const char *)

ПК>>>А зачем обе версии: и operator << (char *x), и operator << (const char *x)?

ПК>#include <iostream>

ПК>class CFoo
ПК>{
ПК>public:
ПК> CFoo & operator << (int x) {
ПК>   std::cout << "operator << (int)" << std::endl;
ПК>   return *this; }

ПК> CFoo & operator << (const char *x)  {
ПК>   std::cout << "operator << (const char *)" << std::endl;
ПК>   return *this; }

ПК> template<class T>
ПК> CFoo & operator << (const T&) {
ПК>   std::cout << "operator << (const T&)" << std::endl;
ПК>   return *this; }
ПК>};

ПК>int main()
ПК>{
ПК>  CFoo f;
ПК>  f << "Число" << 5 ;

ПК>  char* c = 0;
ПК>  f << c;
ПК>}
ПК>

ПК>operator << (const char *)
ПК>operator << (int)
ПК>operator << (const char *)
ПК>

operator << (const char *)
operator << (int)
operator << (const T&)
Press any key to continue

void put(const char *);
void put(int);
void put(unsigned int);
void put(long long); // или __int64
void put(unsigned long long); // или unsigned __int64

class A
{
public:
   A & operator <<(const char *);
   A & operator <<(int);
};

void f(const char*);
void f(const char(&)[6]);

int main()
{
  f("число");
}

"ComeauTest.c", line 6: error: more than one instance of overloaded function "f"
          matches the argument list, the choices that match are:
            function "f(const char *)"
            function "f(const char (&)[6])"
            The argument types that you used are: (const char [6])
    f("число");
    ^

void fun(const int *);
void fun(const int * &);

void g()
{
    int * p = 0;
    fun(p);
}

/* main.cpp */ 

#include <iostream>

using namespace std;

/* main() */ 

void test(const char * &) { cout << "1\n" ; }

void test(char * &) { cout << "2\n" ; }

void test(const char (&)[2]) { cout << "3\n" ; }

int main()
 {
  test("x");
 
  return 0;
 }

— Standard conversion sequence S1 is a better conversion sequence than standard conversion sequence
S2 if

— S1 is a proper subsequence of S2 (comparing the conversion sequences in the canonical form
defined by 13.3.3.1.1, excluding any Lvalue Transformation; the identity conversion sequence is
considered to be a subsequence of any nonidentity
conversion sequence) or, if not that,

When a parameter of reference type binds directly (8.5.3) to an argument expression, the implicit conversion
sequence is the identity conversion, unless the argument expression has a type that is a derived class of
the parameter type, in which case the implicit conversion sequence is a derived to base
Conversion.

> void test(const char * &) { cout << "1\n" ; }
>
> void test(char * &) { cout << "2\n" ; }
>
> void test(const char (&)[2]) { cout << "3\n" ; }
>
> int main()
>  {
>   test("x");
>

void test(const char *);
void test(const char (&)[2]);

void test(char const *&);
void test(const char (&)[2]);

ПК>void test(const char *);
ПК>void test(const char (&)[2]);
ПК>

ПК>void test(char const *&);
ПК>void test(const char (&)[2]);
ПК>

void test(const char (&)[2]);

void test(const char *const &);

/* main.cpp */ 

#include <iostream>

using namespace std;

/* main() */ 

template <class T>
void test(const T &) { cout << "1\n" ; }

void test(const char *) { cout << "2\n" ; }

int main()
 {
  test("x");
  
  char *c=0;
  
  test(c);
 
  return 0;
 }

> template <class T>
> void test(const T &) { cout << "1\n" ; }
>
> void test(const char *) { cout << "2\n" ; }
>
> int main()
>  {
>   test("x");
>  char *c=0;
>  test(c);
>  return 0;
>  }
>

• Почему при вызове test("x") должна быть вызвана вторая функция. После вывода аргумента шаблона компилятор стоит перед выбором из двух сигнатур:
  

  typedef const char T [2];
  void test(const T&);
  void test(const char *);

  
  Т.к. cv-квалификаторы, примененные к массивам, переносятся на их элементы (8.3.4/1), это эквивалентно:
  

  void test(const char (&) [2]);
  void test(const char *);

  
  Что дает неоднозначность, как я уже описал выше
  Автор: Павел Кузнецов
  Дата: 30.05.04
  . Однако т.к. первая функция является специализацией шаблона, то "выигрывает" вторая.
  
• Почему при вызове test(c) должна быть вызвана первая функция. После вывода аргументов шаблона компилятор имеет дело с двумя сигнатурами:
  

  typedef char* T;
  void test(const T&);
  void test(const char*);

  
  Соответственно:
  

  void test(char* const&);
  void test(const char*);

  
  Здесь уже ситуация отличается: преобразование char* -> const char* является Qualification conversion и, хотя имеет тот же ранг Exact Match, что и array-to-pointer conversion, относится к категории Qualification Adjustment, а не Lvalue Transformation. Это означает, что исключение относительно Lvalue Transformations из 13.3.3.2/3 на него не действует, и, соответственно, первая сигнатура "побеждает".