Как обрабатывать значения по умолчанию в (глубоко) вложенных вызовах функций?

Question

Предположим, что существует функция со значением по умолчанию:

int foo(int x=42); 

Если это называется другими, как это:

int bar(int x=42) { return foo(x); } 
int moo(int x=42) { return bar(x); } 

Это, конечно, просто надуманный пример. Тем не менее, иногда у меня очень похожая ситуация. Параметр только что передается с самого высокого уровня (moo) до самого низкого уровня, и только там он фактически используется. Плохая вещь об этом заключается в том, что когда я изменяю foo, чтобы иметь значение по умолчанию, отличное от 42, мне пришлось бы искать всех абонентов и соответственно менять значение по умолчанию.

Есть ли какой-нибудь шаблон/идиома, чтобы избежать этой ситуации?

Единственное простое решение, которое приходит на ум, это

int bar()  { return foo(); } 
int bar(int x) { return foo(x); } 

Однако, как я немного ленив и в реальном коде это приведет к довольно кода дублирования, я хотел бы избежать этого.

Answer 1

Практические общие решения включают в себя:

• Используйте Optional_ класс для аргумента, такие как boost::optional или сделай сам эквивалент.

• Назовите значение по умолчанию (и используйте имя в определениях функций оболочки).

• Перегрузите каждую функцию обертки, как вы показали в вопросе.

• Просто повторите значение по умолчанию в определениях функций оболочки, но это нарушает принцип DRY, не повторяйте себя.

---

В comment else-thread Tobi вызывает случай обертки asdf определяются как

int asdf(int x=42,int y=42){ return foo(x)+foo(y);} 

, используя Optional_ класс:

auto foo(Optional_<int> x) 
    -> int 
{ return (x.is_empty()? 42 : x.value()); } 

auto asdf(Optional_<int> x = {}, Optional_<int> y = {}) 
    -> int 
{ return foo(x) + foo(y); } 

Использование имени значения по умолчанию:

Использование перегруженных:

auto foo(int x = 42) 
    -> int 
{ return x; } 

auto asdf() 
    -> int 
{ return foo() + foo(); } 

auto asdf(int x) 
    -> int 
{ return foo(x) + foo(); } 

auto asdf(int x, int y) 
    -> int 
{ return foo(x) + foo(y); } 

---

Стоит отметить, что asdf не может быть легко определен как шаблон функции переадресации аргументов. Кроме того, такой шаблон не может быть легко определен в отдельной единицы перевода, и его адрес невозможен. По этим причинам я не включил это возможное решение в список пулей: это очень ограниченное, а не общее решение.

Answer 2

Я бы посоветовал выбрать один из этих двух вариантов ниже (как вы можете видеть в других ответах - есть более возможные решения).

1. перегружать функции
2. Определить константу

Таким образом, вариант 1 будет выглядит, как показано ниже:

int foo(int x=42); 
int bar(int x) { return foo(x); } 
int moo(int x) { return bar(x); } 
int bar() { return foo(); } 
int moo() { return bar(); } 

А, вариант 2 будет немного короче:

constexpr int FOO_DEFAULT = 42; 
int foo(int x=FOO_DEFAULT); 
int bar(int x=FOO_DEFAULT) { return foo(x); } 
int moo(int x=FOO_DEFAULT) { return bar(x); } 

Я бы использовал o ption-1 для случаев с небольшим числом значений по умолчанию (как один значение по умолчанию), вариант-2 для случаев, когда у вас есть довольно много значений по умолчанию - как foo(int a, int b = 3, std::string c = "wow", float pi = 3.14)

Answer 3

Вы можете избежать дублирования:

template<typename... T> 
    auto bar(T&&... t) { return foo(std::forward<T>(t)...); } 

Но это не улучшение ИМХО. Просто перестаньте лениться и определите перегрузки, которые вызывают foo(), когда аргументы не предусмотрены.