Wartość domyślna do parametru podczas przekazywania przez odwołanie w C ++

Czy jest możliwe nadanie wartości domyślnej parametrowi funkcji, gdy przekazujemy parametr przez odniesienie? w C ++

Na przykład, gdy próbuję zadeklarować funkcję taką jak:

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

Kiedy to robię, wyświetla błąd:

błąd C2440: „domyślny argument”: nie można przekonwertować z „const int” na „unsigned long” & „Odwołanie, które nie jest do„ const ”, nie może być powiązane z wartością inną niż l

Możesz to zrobić dla odwołania do stałej, ale nie dla odniesienia innego niż stała. Dzieje się tak, ponieważ C ++ nie pozwala na tymczasowe (w tym przypadku wartość domyślną) powiązanie z odwołaniem niebędącym stałym.

Jednym ze sposobów byłoby użycie rzeczywistej instancji jako domyślnej:

static int AVAL = 1;

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

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

ale ma to bardzo ograniczone praktyczne zastosowanie.

Zostało to już powiedziane w jednym z bezpośrednich komentarzy do Twojej odpowiedzi, ale tylko po to, aby oficjalnie to stwierdzić. To, czego chcesz użyć, to przeciążenie:

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

Używanie przeciążeń funkcji ma również dodatkowe zalety. Po pierwsze, możesz ustawić domyślny dowolny argument:

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...

Możliwe jest również przedefiniowanie domyślnych argumentów na funkcje wirtualne w klasie pochodnej, co pozwala uniknąć przeciążenia:

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
}

Jest tylko jedna sytuacja, w której naprawdę trzeba użyć wartości domyślnej, a jest to konstruktor. Nie jest możliwe wywołanie jednego konstruktora z innego, więc ta technika nie działa w tym przypadku.

Wciąż istnieje stary sposób C na dostarczanie opcjonalnych argumentów: wskaźnik, który może mieć wartość NULL, gdy nie jest obecny:

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

Ten mały szablon pomoże ci:

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

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

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

private:
    T mValue;
};

Wtedy będziesz mógł:

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

Nie, to niemożliwe.

Przekazywanie przez odwołanie oznacza, że ​​funkcja może zmienić wartość parametru. Jeśli parametr nie jest dostarczany przez obiekt wywołujący i pochodzi z domyślnej stałej, co ma zmienić funkcja?

Istnieją dwa powody, dla których należy przekazać argument przez odwołanie: (1) ze względu na wydajność (w takim przypadku chcesz przekazać przez odwołanie do stałej) i (2), ponieważ potrzebujesz możliwości zmiany wartości argumentu wewnątrz funkcji.

Wątpię, czy zbyt długi czas poświęcony nowoczesnym architekturom zbytnio Cię spowolni. Zakładam więc, że zamierzasz zmienić wartość Statewewnątrz metody. Kompilator narzeka, ponieważ stałej 0nie można zmienić, ponieważ jest to wartość r („non-lvalue” w komunikacie o błędzie) i niezmienna (const w komunikacie o błędzie).

Mówiąc najprościej, potrzebujesz metody, która może zmienić przekazany argument, ale domyślnie chcesz przekazać argument, którego nie można zmienić.

Inaczej mówiąc, elementy niebędące constreferencjami muszą odnosić się do rzeczywistych zmiennych. Wartość domyślna funkcji signature ( 0) nie jest rzeczywistą zmienną. Masz ten sam problem, co:

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

Jeśli w rzeczywistości nie zamierzasz zmieniać Statew metodzie, możesz po prostu zmienić ją na const ULONG&. Ale nie odniesiesz z tego dużej korzyści z wydajności, więc poleciłbym zmienić to na nie-odniesienie ULONG. Zauważyłem, że zwracasz już a ULONG, i mam podstępne podejrzenie, że jego wartość jest wartością Statepo wszelkich potrzebnych modyfikacjach. W takim przypadku po prostu zadeklarowałbym metodę jako taką:

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

Oczywiście nie jestem pewien, co piszesz ani gdzie. Ale to kolejne pytanie na inny czas.

Nie można użyć stałego literału dla parametru domyślnego z tego samego powodu, dla którego nie można użyć go jako parametru do wywołania funkcji. Wartości odniesienia muszą mieć adres, stałe wartości odniesienia nie muszą (tj. Mogą to być wartości r lub stałe literały).

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

foo(0); // compiler error.

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

bar(0); // ok.

Upewnij się, że wartość domyślna ma adres i wszystko w porządku.

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

Użyłem tego wzorca kilka razy, gdy miałem parametr, który mógł być zmienną lub zerową. W takim przypadku zwykłym podejściem jest podanie przez użytkownika wskaźnika. Przekazują wskaźnik NULL, jeśli nie chcą, abyś wpisał wartość. Lubię podejście zerowe. Ułatwia życie dzwoniącym bez strasznego komplikowania kodu wywołującego.

Myślę, że nie, a powodem jest to, że wartości domyślne są oceniane jako stałe, a wartości przekazywane przez odniesienie muszą być w stanie zmienić, chyba że zadeklarujesz również, że jest to stałe odniesienie.

Innym sposobem może być:

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

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

wtedy możliwe są następujące połączenia:

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

W przypadku OO ... Powiedzieć, że dana klasa ma i „Domyślna” oznacza, że ​​ta wartość domyślna (wartość) musi być zadeklarowana odpowiednio, a następnie może być USD jako parametr domyślny, np .:

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

O Twojej metodzie ...

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

To rozwiązanie jest całkiem odpowiednie, ponieważ w tym przypadku „Globalna domyślna paginacja” jest pojedynczą wartością „odniesienia”. Będziesz mieć również możliwość zmiany wartości domyślnych w czasie wykonywania, takich jak konfiguracja „na poziomie globalnym”, np. Preferencje nawigacji po stronicowaniu użytkowników itp.

Jest to możliwe z kwalifikatorem const dla State:

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

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

Jest na to dość brudna sztuczka:

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

W takim przypadku musisz zadzwonić za pomocą std::move:

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

To tylko zabawne obejście, całkowicie nie polecam używania go w prawdziwym kodzie!

Mam obejście tego problemu, zobacz następujący przykład dotyczący wartości domyślnej dla int&:

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

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

}

Można to zrobić za każdym trywialny typu danych, które chcesz, takich jak bool, double...

Zdefiniuj 2 funkcje przeciążenia.

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

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

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

Odpowiedź jest dość prosta i nie jestem zbyt dobry w wyjaśnianiu, ale jeśli chcesz przekazać domyślną wartość do parametru innego niż const, który prawdopodobnie zostanie zmodyfikowany w tej funkcji, użyj go w następujący sposób:

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