Функция передана как аргумент шаблона

Да, это действительно так.

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

template <typename F>
void doOperation(F f)
{
  int temp=0;
  f(temp);
  std::cout << "Result is " << temp << std::endl;
}

который теперь можно назвать либо:

doOperation(add2);
doOperation(add3());

Посмотреть вживую

Проблема в том, что компилятору сложно встроить вызов add2, поскольку все, что компилятор знает, это то, что тип указателя функции void (*)(int &) передается в doOperation. (Но add3, будучи функтором, может быть легко встроен. Здесь компилятор знает, что в функцию передается объект типа add3, что означает, что вызываемой функцией является add3::operator(), а не просто какой-то неизвестный указатель на функцию.)

Параметры шаблона могут быть параметризованы либо по типу (имя типа T), либо по значению (int X).

«Традиционный» способ создания шаблона в C ++ для фрагмента кода - использовать функтор, то есть код находится в объекте, и объект, таким образом, придает коду уникальный тип.

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

template<typename OP>
int do_op(int a, int b, OP op)
{
  return op(a,b);
}
int add(int a, int b) { return a + b; }
...

int c = do_op(4,5,add);

Не эквивалентно случаю функтора. В этом примере do_op создается для всех указателей на функции, подпись которых - int X (int, int). Компилятор должен быть довольно агрессивным, чтобы полностью встроить этот случай. (Я не исключаю этого, поскольку оптимизация компилятора стала довольно продвинутой.)

Один из способов сказать, что этот код не совсем выполняет то, что мы хотим:

int (* func_ptr)(int, int) = add;
int c = do_op(4,5,func_ptr);

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

typedef int(*binary_int_op)(int, int); // signature for all valid template params
template<binary_int_op op>
int do_op(int a, int b)
{
 return op(a,b);
}
int add(int a, int b) { return a + b; }
...
int c = do_op<add>(4,5);

В этом случае каждая инстанцируемая версия do_op инстанцируется с определенной уже доступной функцией. Таким образом, мы ожидаем, что код для do_op будет очень похож на "return a + b". (Программисты Lisp, перестаньте ухмыляться!)

Мы также можем подтвердить, что это ближе к тому, что мы хотим, потому что это:

int (* func_ptr)(int,int) = add;
int c = do_op<func_ptr>(4,5);

не скомпилируется. GCC говорит: «ошибка: 'func_ptr' не может появиться в константном выражении. Другими словами, я не могу полностью развернуть do_op, потому что вы не предоставили мне достаточно информации во время компиляции, чтобы узнать, какова наша операция.

Итак, если второй пример действительно полностью встраивает нашу операцию, а первый - нет, что хорошего в шаблоне? Что он делает? Ответ: принуждение типа. Этот рифф в первом примере будет работать:

template<typename OP>
int do_op(int a, int b, OP op) { return op(a,b); }
float fadd(float a, float b) { return a+b; }
...
int c = do_op(4,5,fadd);

Этот пример будет работать! (Я не утверждаю, что это хороший C ++, но ...) Произошло то, что do_op был шаблонизирован вокруг сигнатур различных функций, и каждый отдельный экземпляр будет писать другой код приведения типов. Таким образом, созданный экземпляр кода для do_op с fadd выглядит примерно так:

convert a and b from int to float.
call the function ptr op with float a and float b.
convert the result back to int and return it.

Для сравнения, наш случай по значению требует точного совпадения аргументов функции.

Указатели функций можно передавать как параметры шаблона и это часть стандартного C ++. Однако в шаблоне они объявлены и используются как функции, а не как указатели на функцию. В шаблоне создания экземпляра передается адрес функции, а не просто имя.

Например:

int i;


void add1(int& i) { i += 1; }

template<void op(int&)>
void do_op_fn_ptr_tpl(int& i) { op(i); }

i = 0;
do_op_fn_ptr_tpl<&add1>(i);

Если вы хотите передать тип функтора в качестве аргумента шаблона:

struct add2_t {
  void operator()(int& i) { i += 2; }
};

template<typename op>
void do_op_fntr_tpl(int& i) {
  op o;
  o(i);
}

i = 0;
do_op_fntr_tpl<add2_t>(i);

В нескольких ответах в качестве аргумента передается экземпляр функтора:

template<typename op>
void do_op_fntr_arg(int& i, op o) { o(i); }

i = 0;
add2_t add2;

// This has the advantage of looking identical whether 
// you pass a functor or a free function:
do_op_fntr_arg(i, add1);
do_op_fntr_arg(i, add2);

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

// non-type (function pointer) template parameter
template<void op(int&)>
void do_op(int& i) { op(i); }

// type (functor class) template parameter
template<typename op>
void do_op(int& i) {
  op o; 
  o(i); 
}

i = 0;
do_op<&add1>(i); // still need address-of operator in the function pointer case.
do_op<add2_t>(i);

Честно говоря, я действительно ожидал, что это не будет компилироваться, но у меня это сработало с gcc-4.8 и Visual Studio 2013.

В вашем шаблоне

template <void (*T)(int &)>
void doOperation()

Параметр T не является параметром шаблона типа. Это означает, что поведение функции шаблона изменяется в зависимости от значения параметра (которое должно быть исправлено во время компиляции, каковы константы указателя функции).

Если вам нужно что-то, что работает как с функциональными объектами, так и с параметрами функций, вам нужен типизированный шаблон. Однако при этом вам также необходимо предоставить экземпляр объекта (либо экземпляр объекта функции, либо указатель функции) функции во время выполнения.

template <class T>
void doOperation(T t)
{
  int temp=0;
  t(temp);
  std::cout << "Result is " << temp << std::endl;
}

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

Причина, по которой ваш пример функтора не работает, заключается в том, что вам нужен экземпляр для вызова operator().

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

typedef T(*binary_T_op)(T, T);

вместо того

typedef int(*binary_int_op)(int, int);

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

template <typename T> struct BinOp
{
    typedef T(*binary_T_op )(T, T); // signature for all valid template params
    template<binary_T_op op>
    T do_op(T a, T b)
    {
       return op(a,b);
    }
};


double mulDouble(double a, double b)
{
    return a * b;
}


BinOp<double> doubleBinOp;

double res = doubleBinOp.do_op<&mulDouble>(4, 5);

В качестве альтернативы BinOp может быть классом со статическим шаблоном метода do_op (...), который затем называется

double res = BinOp<double>::do_op<&mulDouble>(4, 5);

Изменить: передача оператора в качестве ссылки не работает. Для простоты понимайте это как указатель на функцию. Вы просто отправляете указатель, а не ссылку. Я думаю, вы пытаетесь написать что-то подобное.

struct Square
{
    double operator()(double number) { return number * number; }
};

template <class Function>
double integrate(Function f, double a, double b, unsigned int intervals)
{
    double delta = (b - a) / intervals, sum = 0.0;

    while(a < b)
    {
        sum += f(a) * delta;
        a += delta;
    }

    return sum;
}

. .

std::cout << "interval : " << i << tab << tab << "intgeration = "
 << integrate(Square(), 0.0, 1.0, 10) << std::endl;