템플릿 매개 변수는 유형 (typename T) 또는 값 (int X)으로 매개 변수화 할 수 있습니다.

코드 조각을 템플릿 화하는 “전통적인”C ++ 방식은 펑터 (functor)를 사용하는 것입니다. 즉, 코드는 객체에 있으므로 객체는 코드에 고유 한 유형을 부여합니다.

전통적인 함수로 작업 할 때이 기술은 잘 작동하지 않습니다. 유형 변경은 특정 함수를 나타내지 않기 때문에 가능한 많은 함수의 서명 만 지정하기 때문입니다. 그래서:

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);

functor 케이스와 동일하지 않습니다. 이 예제에서 서명이 int X (int, int) 인 모든 함수 포인터에 대해 do_op가 인스턴스화됩니다. 이 경우를 완전히 인라인하려면 컴파일러가 매우 공격적이어야합니다. (컴파일러 최적화가 상당히 발전함에 따라 배제하지는 않습니다.)

이 코드가 우리가 원하는 것을 수행하지 못한다는 것을 알리는 한 가지 방법은 다음과 같습니다.

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”처럼 보일 것으로 기대합니다. (Lips programmers, 당신의 능글 맞은 웃음을 멈 추세 요!)

또한 이것이 다음과 같은 이유로 우리가 원하는 것에 더 가깝다는 것을 확인할 수 있습니다.

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

컴파일에 실패합니다. GCC는 “오류 : ‘func_ptr’은 상수 표현으로 나타날 수 없습니다. 즉, 컴파일러 시간에 우리의 op가 무엇인지 알 수있는 정보를 충분히 얻지 못했기 때문에 do_op을 완전히 확장 할 수 없습니다.

두 번째 예가 실제로 우리의 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은 다양한 함수 의 시그니처 주위에 템플릿 화되어 있으며 각 개별 인스턴스화는 다른 유형의 강제 코드를 작성합니다. 따라서 fadd가있는 do_op의 인스턴스화 된 코드는 다음과 같습니다.

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.

이와 비교해 볼 때, 값 단위의 경우 함수 인수와 정확히 일치해야합니다.

답변

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);

// 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);

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

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

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;