Voici un petit code :

void fonc(const int*& test)
{
}

void fonc2(int* test)
{
}

int main()
{
int* t = 0;
fonc(t);
//fonc2(t);
return 0;
}

J´ai une erreur sur l´appel de fonc, impossible de caster ´int *´ en ´const int *&´
testé sous Visual C++ et gcc Linux.

Il est vrai qu´au niveau sémantique, le seul avantage de passer un pointeur par référence est de pouvoir le réallouer. Donc y mettre un const avant n´a pas d´intéret : autant passer le pointeur par recopie (sachant que passer un pointeur par recopie ou bien une référence, ça recopie toujours sizeof(void*), donc on n´y gagne pas en recopie)

Mais il y a quand meme un truc qui m´échappe : pourquoi est ce que ça ne veut pas compiler ? C´est pas bien malin de le faire, ok, mais pourquoi :

void fonc(const int*& t) // fonction
int* t; // appel
fonc(t);

ne passe pas, alors que :

void fonc(const int& t) // fonction
int t; // appel
fonc(t);

passe bien ?

ahah, tu t´es fait avoir par const!

quand tu fais:
void fonc(const int* & test)
int* t = 0;
fonc(t);

gcc te dit:
error: invalid initialization of reference of type ‘const int*&’ from expression of type ‘int*’

mais si tu ecris:
fonc((const int*)t);
l´erreur devient:
error: invalid initialization of non-const reference of type ‘const int*&’ from a temporary of type ‘const int*’

et tout devient clair!
ce n´est pas la reference qui est constante dans: const int* & c´est la donné pointé!

tu voulais probablement ecrire:
void fonc( int* const & test)
int* t = 0;
fonc(t);

Arf !

La priorité des opérateurs !
C´est vrai que moi, j´y voyais comme ça implicitement :

void fonc(const (int*) & )

et le compilo comme ça :

void fonc((const int*) & )

Ceci explique cela

Cela dit, ce n´était pas quelque chose de bloquant pour moi, c´était juste un test tordu, et je ne comprenais pas la réaction du compilo
Je comprends mieux maintenant !