Przechodząc opcjonalny parametr przez odniesienie w C++

Question

Mam problem z opcjonalnego parametru funkcji w C++

Co staram się zrobić to funkcję z opcjonalnym parametrem, który jest przekazywany przez odniesienie pisać, tak że mogę używaj go na dwa sposoby (1) i (2), ale na (2) nie obchodzi mnie, jaka jest wartość mFoobar.

Próbowałem taki kod:

void foo(double &bar, double &foobar = NULL) 
{ 
    bar = 100; 
    foobar = 150; 
} 

int main() 
{ 
    double mBar(0),mFoobar(0); 

    foo(mBar,mFoobar);    // (1) 
    cout << mBar << mFoobar; 

    mBar = 0; 
    mFoobar = 0; 

    foo(mBar);      // (2) 
    cout << mBar << mFoobar; 

    return 0; 
} 

ale wywala na

void foo(double &bar, double &foobar = NULL) 

z komunikatem:

error: default argument for 'double& foobar' has type 'int' 

Czy to możliwe, aby go rozwiązać bez przeciążania funkcji?

Answer 1

Domyślnym argumentem odniesienia (zmiennego) musi być wartość l. Najlepsze, co mogę myśleć, bez przeciążania, jest

Answer 2

Dlaczego nie możesz używać funkcji przeciążania? Z pewnością jest to najprostsze rozwiązanie twojego problemu?

void foo(double &bar, double &foobar) 
{ 
    bar = 100; 
    foobar = 150; 
} 

void foo(double &bar) 
{ 
    double foobar = 0.0; 
    foo(bar, foobar); 
} 

Answer 3

Nie używaj referencji dla opcjonalnych parametrów. Nie ma koncepcji odniesienia NULL: referencja jest zawsze aliasem do konkretnego obiektu.

Być może spójrz na boost::optional lub std::experimental::optional. boost::optional jest nawet wyspecjalizowany dla typów referencyjnych!

void foo(double &bar, optional<double &> foobar = optional<double &>()) 

Answer 4

Można zrobić ten szalony sposób:

void foo(double &bar, double &foobar = (*(new double()))) 

PS: - Wiem, że to nie jest przyjemne, ale jest po drodze. Należy również pamiętać, aby nie pozostawiać wycieków pamięci! :))

Answer 5

Innym sposobem na to jest użycie wskaźników zamiast referencji. Zapewnia to pożądaną semantykę bez przeciążania. (Osobiście, pewnie bym go z przeciążenia.)

void foo(double* bar, double* foobar = 0) 
{ 
    if (bar) *bar = 100; 
    if (foobar) *foobar = 150; 
} 

    // ... 

    foo(&mBar, &mFoobar); 

    // ... 

    foo(&mBar); 

    // ... 

Answer 6

Oto kolejny zwariowany sposób, który nie powoduje wycieki pamięci, które nigdy nie powinno się używać w prawdziwym życiu, ale wydaje się być standardem zgodny na pierwszy rzut oka i zestawia z Visual C++ 2008 & g ++ 3.4.4 pod Cygwin:

void foo(double &bar, double &foobar = (*((double*)0))) 
{ 
    bar = 100; 
    double* pfoobar = &foobar; 
    if (pfoobar != 0) 
     foobar = 150; 
} 

Powtórzmy: NIE ROBIĆ TO! TAM JEST LEPSZE OPCJE! PRZETWARZANIE MOŻE BYĆ PRZYJACIELEM! Ale tak, możesz to zrobić, jeśli jesteś głupi i ostrożny. :)

Answer 7

Znacznie łatwiej jest użyć typu wskaźnika i ustawić go na wartość NULL niż ustawienie wartości domyślnej/opcjonalnej dla parametru odniesienia.

Answer 8

Mówiąc w kategoriach Object Oriented paradygmatu: Jeżeli dana klasa ma i „Default”, to domyślna musi odpowiednio zadeklarowane, a następnie mogą być wykorzystane jako „Default parametr” Ex:

class Pagination { 
private: 
    int currentPage; 
public: 

    //... 
    Pagination() { 
     currentPage = 1; 
     //... 
    } 

    // your Default Pagination (Must be initialized before thread concurrency) 
    static Pagination& Default() { 
     static Pagination p; 
     return p; 
    } 
}; 

na własną metoda ...

 //... 
    std::vector<User> 
    findByFilter(User& audit, Pagination& p = Pagination::Default()) { 
    // ... 

Zmieniano: to rozwiązanie jest całkiem odpowiednie, ponieważ w tym przypadku jest to „globalna default” Paginacja i pojedyncza wartość „odniesienia”. Będziesz mieć również uprawnienia do zmiany wartości domyślnych, takich jak nawigacja/preferencje wyświetlania itp

Edit2: ortograficzny i mocowania ...