Valor padrão para um parâmetro ao passar por referência em C ++

É possível dar um valor padrão a um parâmetro de uma função enquanto passamos o parâmetro por referência. em C ++

Por exemplo, quando tento declarar uma função como:

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

Quando faço isso, ocorre um erro:

erro C2440: 'argumento padrão': não é possível converter de 'const int' para 'unsigned long &' Uma referência que não é para 'const' não pode ser associada a um não-lvalue

Você pode fazer isso para uma referência const, mas não para uma não const. Isso ocorre porque o C ++ não permite que um temporário (o valor padrão neste caso) seja vinculado a uma referência não constante.

Uma maneira de contornar isso seria usar uma instância real como padrão:

static int AVAL = 1;

void f( int & x = AVAL ) {
   // stuff
} 

int main() {
     f();       // equivalent to f(AVAL);
}

mas isso é de uso prático muito limitado.

Isso já foi dito em um dos comentários diretos à sua resposta, mas apenas para declará-lo oficialmente. O que você deseja usar é uma sobrecarga:

virtual const ULONG Write(ULONG &State, bool sequence);
inline const ULONG Write()
{
  ULONG state;
  bool sequence = true;
  Write (state, sequence);
}

Usar sobrecargas de funções também traz benefícios adicionais. Em primeiro lugar, você pode usar como padrão qualquer argumento que desejar:

class A {}; 
class B {}; 
class C {};

void foo (A const &, B const &, C const &);
void foo (B const &, C const &); // A defaulted
void foo (A const &, C const &); // B defaulted
void foo (C const &); // A & B defaulted etc...

Também é possível redefinir os argumentos padrão para funções virtuais na classe derivada, o que evita a sobrecarga:

class Base {
public:
  virtual void f1 (int i = 0);  // default '0'

  virtual void f2 (int);
  inline void f2 () {
    f2(0);                      // equivalent to default of '0'
  }
};

class Derived : public Base{
public:
  virtual void f1 (int i = 10);  // default '10'

  using Base::f2;
  virtual void f2 (int);
};

void bar ()
{
  Derived d;
  Base & b (d);
  d.f1 ();   // '10' used
  b.f1 ();   // '0' used

  d.f2 ();   // f1(int) called with '0' 
  b.f2 ();   // f1(int) called with '0
}

Existe apenas uma situação em que um padrão realmente precisa ser usado, e é em um construtor. Não é possível chamar um construtor de outro e, portanto, essa técnica não funciona nesse caso.

Ainda existe a velha maneira C de fornecer argumentos opcionais: um ponteiro que pode ser NULL quando não está presente:

void write( int *optional = 0 ) {
    if (optional) *optional = 5;
}

Este pequeno modelo irá ajudá-lo a:

template<typename T> class ByRef {
public:
    ByRef() {
    }

    ByRef(const T value) : mValue(value) {
    }

    operator T&() const {
        return((T&)mValue);
    }

private:
    T mValue;
};

Então você será capaz de:

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

Não, não é possível.

A passagem por referência implica que a função pode alterar o valor do parâmetro. Se o parâmetro não for fornecido pelo chamador e vier da constante padrão, o que a função deve mudar?

Há duas razões para passar um argumento por referência: (1) para desempenho (nesse caso, você deseja passar por referência const) e (2) porque você precisa da capacidade de alterar o valor do argumento dentro da função.

Eu duvido muito que passar um longo tempo sem sinal em arquiteturas modernas esteja atrasando você demais. Portanto, estou assumindo que você pretende alterar o valor de Statedentro do método. O compilador está reclamando porque a constante 0não pode ser alterada, pois é um rvalue ("não-lvalue" na mensagem de erro) e imutável ( constna mensagem de erro).

Simplificando, você quer um método que pode mudar o argumento passado, mas por padrão você deseja passar um argumento que não pode mudar.

Em outras palavras, as não constreferências têm que se referir a variáveis ​​reais. O valor padrão na assinatura da função ( 0) não é uma variável real. Você está tendo o mesmo problema que:

struct Foo {
    virtual ULONG Write(ULONG& State, bool sequence = true);
};

Foo f;
ULONG s = 5;
f.Write(s); // perfectly OK, because s is a real variable
f.Write(0); // compiler error, 0 is not a real variable
            // if the value of 0 were changed in the function,
            // I would have no way to refer to the new value

Se você realmente não pretende alterar Statedentro do método, pode simplesmente alterá-lo para um const ULONG&. Mas você não terá um grande benefício de desempenho com isso, então eu recomendo alterá-lo para um não-referência ULONG. Percebi que você já está retornando a ULONGe tenho uma leve suspeita de que seu valor é o valor de Stateapós quaisquer modificações necessárias. Nesse caso, eu simplesmente declararia o método assim:

// returns value of State
virtual ULONG Write(ULONG State = 0, bool sequence = true);

Claro, não tenho certeza do que você está escrevendo ou para onde. Mas essa é outra questão para outra hora.

Você não pode usar um literal constante para um parâmetro padrão pelo mesmo motivo que você não pode usar um como um parâmetro para a chamada de função. Os valores de referência devem ter um endereço, os valores de referência constantes não precisam (ou seja, podem ser valores r ou literais constantes).

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

foo(0); // compiler error.

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

bar(0); // ok.

Certifique-se de que seu valor padrão tem um endereço e você está bem.

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;
   }
}

Usei esse padrão algumas vezes onde tinha um parâmetro que poderia ser uma variável ou nulo. A abordagem normal é fazer com que o usuário passe um ponteiro, neste caso. Eles passam um ponteiro NULL se não quiserem que você preencha o valor. Eu gosto de abordagem de objeto nulo. Facilita a vida do chamador sem complicar terrivelmente o código do receptor.

Acho que não, e o motivo é que os valores padrão são avaliados como constantes e os valores passados ​​por referência devem poder mudar, a menos que você também declare que é uma referência constante.

Outra forma poderia ser a seguinte:

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

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

então as seguintes chamadas são possíveis:

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"

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

No caso de OO ... Dizer que uma determinada classe tem e "Padrão" significa que esse padrão (valor) deve ser declarado em seguida e pode ser usado como um parâmetro padrão ex:

class Pagination {
public:
    int currentPage;
    //...
    Pagination() {
        currentPage = 1;
        //...
    }
    // your Default Pagination
    static Pagination& Default() {
        static Pagination pag;
        return pag;
    }
};

No seu método ...

 shared_ptr<vector<Auditoria> > 
 findByFilter(Auditoria& audit, Pagination& pagination = Pagination::Default() ) {

Esta solução é bastante adequada, pois, neste caso, "Paginação padrão global" é um único valor de "referência". Você também terá o poder de alterar os valores padrão em tempo de execução, como uma configuração de "nível gobal", por exemplo: preferências de navegação de paginação do usuário e etc.

É possível com o qualificador const para o estado:

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

void revealSelection(const ScrollAlignment& = ScrollAlignment::alignCenterIfNeeded, bool revealExtent = false);

Também há um truque bastante sujo para isso:

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

Neste caso, você deve chamá-lo com std::move :

ULONG val = 0;
Write(std::move(val));

É apenas uma alternativa engraçada, eu totalmente não recomendo usar em código real!

Eu tenho uma solução alternativa para isso, veja o seguinte exemplo sobre o valor padrão para int&:

class Helper
{
public:
    int x;
    operator int&() { return x; }
};

// How to use it:
void foo(int &x = Helper())
{

}

Você pode fazer isso para qualquer tipo de dados trivial que desejar, como bool, double...

Defina 2 funções de sobrecarga.

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

virtual const ULONG Write(bool sequence = true)
{
    int State = 0;
    return Write(State, sequence);
}

gravação ULONG const virtual (ULONG & State = 0, sequência booleana = verdadeiro);

A resposta é bastante simples e não sou muito bom em explicar, mas se você quiser passar um valor padrão para um parâmetro não const que provavelmente será modificado nesta função é usá-lo assim:

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