Funkcja przeciążenia w C++ argumentów przechodzących przez wartość lub przez odwołanie

Question

Jeśli mamy ten przykładowy kod funkcji w C++

void foo(int x) { std::cout << "foo(int)" << std::endl; } 
void foo(int& x) { std::cout << "foo(int &)" << std::endl; } 

Czy możliwe jest różnicą jaką funkcję zadzwonić robić żadnych zmian w argumentach dzwoni?

Jeśli foo funkcja nazywa się w niektórych z tych sposobów:

foo(10); 

i = 10; 
foo(static_cast<const int>(i)); 

foo(static_cast<const int&>(i)); 

to się nazywa pierwszy foo przeciążony funkcję, ponieważ nie może przechodzić przez odniesienie const argument const parametru. Ale jak możesz zadzwonić do drugiej funkcji przeciążenia foo? Gdybym wywołać następny sposób:

int i = 10; 
foo(i); 

Zdarza niejednoznaczne błąd, ponieważ obie funkcje są ważne dla tego argumentu.

W tym linku https://stackoverflow.com/a/5465379/6717386 wyjaśniono, w jaki sposób można go rozwiązać: używając obiektów zamiast wbudowanych typów i wykonując prywatny konstruktor kopiowania, więc nie można wykonać kopii wartości obiektu i należy go nazwać drugim foo przeciążenie i przekazanie obiektu przez odniesienie. Ale czy istnieje jakiś sposób z wbudowanymi typami? Muszę zmienić nazwę funkcji, aby uniknąć przeciążenia?

Answer 1

Można zrobić odlew (funkcji), aby wybrać funkcję przeciążeniem:

static_cast<void (&)(int&)>(foo)(i); 

Demo

Answer 2

W większości instancji, funkcja przeciążenia obejmuje różne typy parametrów i różnych długościach parametrów wejściowych.

Twoja próba jest ogólnie złą praktyką, a wynikowy skompilowany kod zależy od kompilatora, a optymalizacja kodu może nawet pogorszyć sytuację.

Można rozważyć prostu dodanie drugiego parametru do drugiego sposobu, coś takiego:

void foo(int x) { std::cout << "foo(int)" << std::endl; } 
void foo(int& x, ...) { std::cout << "foo(int &, ...)" << std::endl; } 

gdzie ... może być typu boolean, powiedzieć: bool anotherFunction

Więc wywołanie foo(param1, param2) po prostu zadzwoń do drugiego kodu i wszyscy są w porządku.

Answer 3

Pomimo dobrej odpowiedzi @ Jarod42, jako alternatywne rozwiązanie można polegać na szablonowym punkcie wejścia i przeciążeniu funkcji wewnętrznej (oczywiście jeśli nie chcemy zajmować się jawnymi rzutami).
Wynika minimalny, przykład pracy:

#include<type_traits> 
#include<iostream> 
#include<utility> 

void foo_i(char, int x) { std::cout << "foo(int)" << std::endl; } 
void foo_i(int, int &x) { std::cout << "foo(int &)" << std::endl; } 

template<typename T> 
void foo(T &&t) { 
    static_assert(std::is_same<std::decay_t<T>, int>::value, "!"); 
    foo_i(0, std::forward<T>(t)); 
} 

int main() { 
    foo(10); 
    int i = 10; 
    foo(static_cast<const int>(i)); 
    foo(static_cast<const int &>(i)); 
    foo(i); 
} 

static_assert służy do sprawdzania parametru być coś, co wiąże int (czyli int, int &, const int &, int & & `, i tak dalej) .

Jak widać z powyższego kodu, foo(i) wypisze:

foo(int &)

jak oczekiwano.

Answer 4

Bardzo dziwny projekt, ale jeśli chcesz ... Zaproponuję rozwiązanie tak dziwne, jak twój projekt. Użyj Xreference w sygnaturze funkcji. Następnie w funkcji możesz sprawdzić, co musisz zrobić, używając std::is_lvalue_reference, std::is_rvalue_reference.
coś takiego

template<class T> 
void foo(T&& x) 
{ 
    static_assert(std::is_same<std::decay_t<T>, int>::value, "!"); 
    if (std::is_rvalue_reference<T&&>::value) 
    std::cout << "do here what you want in foo(int x)"; 
    else 
    std::cout << "do here what you want in foo(int & x)"; 
} 

int main() 
{ 
    int x = 5; 
    foo(x); //"do here what you want in foo(int x)" - will be printed 
    foo(std::move(x)); //"do here what you want in foo(int & x)" - will be printed 
} 

Answer 5

Inny:

#include <iostream> 
#include <functional> 

void foo(int x) 
{ 
    std::cout << "foo(int)\n"; 
} 

template<typename T> 
void foo(T&& x) 
{ 
    std::cout << "foo(int&)\n"; 
} 

int main() 
{ 
    int i = 10; 
    foo(i);   // foo(int) 
    foo(std::ref(i)); // foo(int&) 
}