Valeur par défaut d'un paramètre lors du passage par référence en C++.

Question

Est-il possible de donner une valeur par défaut à un paramètre d'une fonction alors que l'on passe le paramètre par référence ? en C++.

Par exemple, lorsque j'essaie de déclarer une fonction comme :

virtual const ULONG Write(ULONG &State = 0, bool sequence = true);

Lorsque je fais cela, il y a une erreur :

error C2440 : 'default argument' : impossible de convertir 'const int' en 'unsigned long &'. Une référence qui n'est pas à 'const' ne peut pas être liée à une non-valeur.

Answer 1

Non, ce n'est pas possible.

Le passage par référence implique que la fonction peut modifier la valeur du paramètre. Si le paramètre n'est pas fourni par l'appelant et provient de la constante par défaut, que doit changer la fonction ?

Answer 2

Vous ne pouvez pas utiliser un littéral constant comme paramètre par défaut pour la même raison que vous ne pouvez pas en utiliser un comme paramètre de l'appel de fonction. Les valeurs de référence doivent avoir une adresse, les valeurs de référence constantes n'en ont pas besoin (c'est-à-dire qu'elles peuvent être des valeurs r ou des littéraux constants).

int* foo (int& i )
{
   return &i;
}

foo(0); // compiler error.

const int* bar ( const int& i )
{
   return &i;
}

bar(0); // ok.

Assurez-vous que votre valeur par défaut a une adresse et tout ira bien.

int null_object = 0;

int Write(int &state = null_object, bool sequence = true)
{
   if( &state == &null_object )
   {
      // called with default paramter
      return sequence? 1: rand();
   }
   else
   {
      // called with user parameter
      state += sequence? 1: rand();
      return state;
   }
}

J'ai utilisé ce modèle à plusieurs reprises lorsque j'avais un paramètre qui pouvait être une variable ou nul. L'approche habituelle consiste à demander à l'utilisateur de passer un pointeur, ce qui est le cas. Il passe un pointeur NULL s'il ne veut pas que vous remplissiez la valeur. J'aime l'approche de l'objet nul. Elle facilite la vie de l'appelant sans compliquer terriblement le code de l'appelé.

Answer 3

Je ne pense pas, et la raison en est que les valeurs par défaut sont évaluées sur des constantes et que les valeurs passées par référence doivent pouvoir changer, à moins que vous ne déclariez également qu'il s'agit d'une référence constante.

Answer 4

Un autre moyen pourrait être le suivant :

virtual const ULONG Write(ULONG &State, bool sequence = true);

// wrapper
const ULONG Write(bool sequence = true)
{
   ULONG dummy;
   return Write(dummy, sequence);
}

alors les appels suivants sont possibles :

ULONG State;
object->Write(State, false); // sequence is false, "returns" State
object->Write(State); // assumes sequence = true, "returns" State
object->Write(false); // sequence is false, no "return"
object->Write(); // assumes sequence = true, no "return"

Answer 5

void f(const double& v = *(double*) NULL)
{
  if (&v == NULL)
    cout << "default" << endl;
  else
    cout << "other " << v << endl;
}