Избежание перегрузки функций

Question

В следующей программе перегружена функция.Один с одним аргументом, другой с двумя аргументами и другой с тремя.В следующем примере это выглядит просто, потому что функция не слишком длинная.Что делать, если функция очень длинная и выглядит уродливо снова и снова писать одну и ту же функцию с разными входными аргументами.Один из способов сделать это может быть variadic functions.Если я знаю, что моя функция будет принимать только 1,2 или 3 входных аргумента, variadic functions действительно необходимо?Если так, как я могу это сделать?Примечание: функция с тремя входными аргументами и двумя входными аргументами выполняет различные вычисления.

#include <iostream>
using namespace std;

int function(int a, int b, int c)  // All the arguments are always of the same type
{
    return a*b*c;
}

int function(int a, int b)
{
    int c = a; // Always duplicate the first argument
    return a*b*c;  
}
int function(int a)
{
    int b = a, c = a; // Always duplicate the first argument
    return a*b*c;
}
int main()
{
    cout<<function(2,3,4)<<"\n"<<function(2,3)<<"\n"<<function(2);
    cin.ignore();
    return 0;
}

РЕДАКТИРОВАТЬ:

Простите за двусмысленность, ребята.Я редактировал код.

Answer 1

Прежде всего, если ваша функция длинная и безобразная, вы должны преобразовать ее в набор более мелких функций или даже классов.

Что касается вашего фактического вопроса, я бы использовал перегруженные функции как оболочки:

int function(int a, int b, int c)
{
  return a * b * c;
}

int function(int a, int b)
{
  return function(a, b, a);
}

int function(int a)
{
  return function(a, a, a);
}

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

Answer 2

Любое решение с переменными функциями будет хуже: для начала, переменная функция не знает, сколько аргументов и какого типа она была вызвана, вам нужны дополнительные аргументы, чтобы это знать.

Answer 3

В своем вопросе вы заявляете, что написание одной и той же длинной функции несколько раз утомительно, И что версии с тремя и двумя входами различаются.В чем дело?

• Если они делают то же самое, просто позвоните одному из другого.Обычно случается, что функции с меньшими параметрами вызывают свое непосредственное превосходство с еще одним параметром, вверх по цепочке, или все перегрузки вызывают одну версию с наибольшим количеством параметров.

• Еслиони делают разные вещи, у вас, вероятно, нет причин перегружать их.Называя их разными именами, можно прояснить ситуацию и ослабить чувство «написания одной и той же функции дважды».

• Если они делают схожие вещи, то есть попадают куда-то между двумя вышеупомянутыми случаямивам, вероятно, понадобятся дополнительные функции для выделения идентичных частей исходных, перегруженных функций.

Ваш пример относится к первой категории:

int function(int a, int b, int c)  // All the arguments are always of the same type
{
    return a*b*c;
}

int function(int a, int b) // Always duplicate the first argument
{
    return function(a,b,a);  
}

int function(int a) // Always duplicate the first argument
{
    return function(a,a);
//  return function(a,a,a); //might make more sense depending on actual function/variable names
}

Answer 4

Я думаю, что решение было бы просто иметь одну функцию с функцией подписи (int, int, int).

Если вы хотите скопировать поведение других вариантов, вы можете сделать это явно,с функцией (a, b, a) вместо функции (a, b).

Answer 5

Похоже, вы должны использовать вместо этого массив:

void Function(int* items, int count)
{
    int result = 1;
    for(int i = 0; i < count; i++)
    {
        result *= items[i];
    }
}

Answer 6

Если расчеты отличаются - это разные функции, у вас нет никаких причин избегать перегрузки.

Evaen, если calc одинаковы, следует избегать функции Variadic_function, которая может выдавать много ошибок (с типами, числом аргументов и т. Д.))

Кроме того, попробуйте сделать это 3 функами как 1 вариацией и скажите, что это менее уродливо.Я буду смеяться

Также переключение для подсчета аргументов является временем выполнения (как в varidiac_function) хуже, чем во время компиляции