Как вызвать функцию с параметром по умолчанию через указатель на функцию, которая является возвращением другой функции?

Question

У меня есть функции Mult, Add, Div, Sub, Mod, которые принимают два целых числа и возвращают результат своих параметров. И функция Calc, которая принимает символ как Operator и возвращает указатель на функцию, которая возвращает целое число и принимает два целочисленных параметра, таких как Mult.

• Функции, подобные второму параметру Mult, равны default Поэтому, когда я вызываю Calc, Calc возвращает адрес Mult или Add ... в зависимости от значения параметра Calc Таким образом, я могу передать только один аргумент.

Но он не работает с указателем на функцию:

int Add(int x, int y = 2) { // y is default
    return x + y;
}

int Mult(int x, int y = 2) { // y is default
    return x * y;
}

int Div(int x, int y = 2) { // y is default
    return y ? x / y : -1;
}

int Sub(int x, int y = 2) { // y is default
    return x - y;
}

int Mod(int x, int y = 2) { // y is default
    return y ? x % y : -1;
}

using pFn = int(*)(int, int);


pFn Calc(char c) {
    switch (c) {
        case '+':
            return Add;
        case '*':
            return Mult;
        case '/':
            return Div;
        case '-':
            return Sub;
        case '%':
            return Mod;
    }
    return Mult;
}

int main(int argc, char* argv[]){

    pFn func = Calc('%');
    cout << func(7, 4) << endl; // ok
    //cout << func(7) << endl; // error:  Too few arguments
    cout << Mult(4) << endl; // ok. the second argument is default

    func = Calc('/'); // ok
    cout << func(75, 12) << endl; // ok

    std::cout << std::endl;
}

Выше, если я вызову Mult с одним аргументом, он работает нормально, потому что второй аргумент является значением по умолчанию, но вызывая его через указатель func, он не работает. func - указатель на функцию, которая принимает два целых числа и возвращает int.

Answer 1

Значения по умолчанию - это немного синтаксического сахара C ++; при непосредственном вызове функции с недостаточными аргументами компилятор вставляет значение по умолчанию, как если бы вызывающая сторона передала его явно, поэтому функция по-прежнему вызывается с полным набором аргументов (Mult(4) компилируется в тот же код, что и Mult(4, 2) в это дело).

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

Answer 2

На вопрос «почему бы и нет» я отсылаю вас к этому ответу . Если вы хотите как-то сохранить возможность использовать значение по умолчанию, вам нужно предоставить что-то большее, чем указатель на функцию, например, lamdba сделает:

auto Double() {
    return [](int x,int y=2){ return Mult(x,y); };
}

А при использовании вариабельной лямбды (благодаря @Artyer) вам даже не нужно повторять значение по умолчанию:

#include <iostream>

int Mult(int x, int y = 2) { // y is default
    return x * y;
}

auto Double() {
    return [](auto... args) { return Mult(args...); };
}

int main(int argc, char* argv[]){    
    auto func = Double();
    std::cout << func(7, 4) << '\n'; // ok
    std::cout << func(7) << '\n';    // ok
    std::cout << Mult(4) << '\n';    // ok
}

Живая демоверсия

Answer 3

Если у вас всегда есть 2 в качестве аргумента по умолчанию, вы можете заключить указатель вашей функции в простой вспомогательный класс, например:

using pFn_ = int(*)(int, int);

class pFn
{
    pFn_ ptr;
public:
    pFn(pFn_ p) : ptr(p) {}
    int operator()(int x, int y = 2) const {
        return ptr(x,y);
    }
};

Полный рабочий пример: https://godbolt.org/z/5r7tZ8