C/C++可变参数模版和函数指针的结合

目录

• 1、说明
• 2、模板类传入固定参数的C函数指针
• 3、模板类传入固定参数的C++函数指针
  • 3.1、用函数对象替代函数指针存储
• 4、模板类传入不定参数的C函数指针
• 5、模板类传入不定参数的C++成员函数指针

最近因为想自己写一个信号槽，看到了一些开源代码，才发现，自己对模版的理解还是太浅了，理解了C++的模版才算真正入门了C++

1、说明

本文只针对技术提炼说明，不对使用场景做介绍。内容的理解需要在理解模板类（包括模板类的使用以及隐式/显式实例化）和C/C++函数指针以及stl函数对象的基础上

下面从以下几点讲解：

1. 模板类传入C函数指针，函数参数固定；
2. 模板类传入C++函数指针，函数参数固定；
3. 模板类传入C函数指针，函数参数不固定；
4. 模板类传入C++函数指针，函数参数不固定

2、模板类传入固定参数的C函数指针

先看一组示例：

template<typename T>
class Test;
template<typename F>
class Test<F(int)>
{
public:
  typedef F(*Callback)(int);

  explicit Test(Callback func)
    : callback(func)
  {}

  void exec()
  {
    callback(999);
  }
private:
  Callback callback;
};

需要执行的函数：

int TestFunction(int value)
{
  cout << value + 2 << endl;
  return value;
}

调用示例：

int main()
{
  Test<int(int)> test(TestFunction);
  test.exec();
  return 0;
}

执行结果：

1001

代码讲解：

template<typename F>
class Test<F(int)>
{}

理解一下上面这段代码做了什么，首先，这 是一个模板类的，并且它也是 模板类的显示实例化，既然是显示实例化，那么就需要模板类的声明，这就是下面第一二行代码的存在意义

template<typename T>
class Test;//模板类声明

这段可以这样理解，这里是先声明一个模板类 Test，它需要传入一个类型T；然后再显示实例化，显示实例化之后的类还是一个模板类，实例化的类需要传入的是一个函数指针（该函数指针就是第一个Test的T的显示实例化类型，即第一个Test的类型T被显示实例化为函数指针），该函数指针的返回值是类型F，参数有且只有一个int型，函数指针的声明如下：

typedef F(*Callback)(int);

所以，我们在使用的时候，需要指定，我们使用的是显示实例化的Test（这个Test类还是一个模板类，但是不同与前一个模板类Test），所以需要明确指定类型，如下所示：

Test<int(int)> test(TestFunction);

这行代码告诉编译器，我们使用的是显示实例化之后的模板类，另外需要再隐式实例化该模板类：

template<typename F>
class Test<F(int)>//隐式实例化，F类型为int
{}

然后使用构造函数，传入C函数指针 TestFunction，执行 exec() 方法的时候，则执行传进入的C函数

3、模板类传入固定参数的C++函数指针

示例代码如下：

template<typename T>
class Test;
template<typename F>
class Test<F(int)>
{
public:
  typedef F(TestClass::*TestCallback)(int);

  explicit Test(TestClass *ptr, TestCallback func)
    : ptr(ptr), testCallback(func)
  {}

  void exec()
  {
    (*ptr.*testCallback)(777);
  }
private:
  TestCallback testCallback;
  TestClass *ptr;
};

需要执行的C++类函数

class TestClass
{
public:
  int TestFunction(int value)
  {
    cout << value + 2 << endl;
    return value;
  }
};

调用方：

int main()
{
  TestClass testClass;
  Test<int(int)> test(&testClass, &TestClass::TestFunction);
  test.exec();

  return 0;
}

执行结果：

779

代码说明：

模板类Test大致同第二节，只是这里的函数指针定义变成了类成员

typedef F(TestClass::*TestCallback)(int);

正因为如此，调用处不能只传一个函数指针，还需要类对象，所以构造函数需要两个变量，如下：

explicit Test(TestClass *ptr, TestCallback func)
    : ptr(ptr), testCallback(func)
  {}

执行函数这段使用类函数指针调用即可（看不懂的回去复习函数指针一文）

void exec()
{
    (*ptr.*testCallback)(777);
}

3.1、用函数对象替代函数指针存储

上面代码分别出处了类对象和类函数指针，C++11中也可组合成函数对象，可以使得代码更直观，代码如下：

template<typename T>
class Test;
template<typename F>
class Test<F(int)>
{
public:
  typedef F(TestClass::*TestCallback)(int);

  explicit Test(TestClass *ptr, TestCallback func)
  {
    testCall = std::bind(func, ptr, std::placeholders::_1);
  }

  void exec()
  {
    testCall(888);
  }
private:
  std::function<F(int)> testCall;
};

代码说明：

这段代码的修改部分就是在构造函数中，不再存储函数指针和函数对象，而是利用C++11的std::bind组合成函数对象，代码的可读性更好，当然C函数也可以使用函数对象，这里不细说

4、模板类传入不定参数的C函数指针

第二节示例代码中传入的C函数是固定参数的函数，如果我们想灵活一点，传入不定参数，则需要做一些改动，示例代码如下：

template<typename T>
class Test;
template<typename F, typename... Args>
class Test<F(Args...)>
{
public:
  typedef F(*Callback)(Args... args);

  explicit Test(Callback callback)
    : callback(callback)
  {}

  void exec()
  {
    callback(11, 22, 33);
  }
private:
  Callback callback;
};

需要执行的C++普通函数

template<typename... Args>
int TestFunction(Args... args)
{
  std::list<int> arg_list = std::initializer_list<int>{args...};
  while (!arg_list.empty())
  {
    cout << arg_list.front() << endl;
    arg_list.pop_front();
  }
  return 0;
}

调用处：

Test<int(int, int, int)> test(TestFunction);
test.exec();

运行结果：

11
22
33

代码说明：

模板类Test需要做一些改动，指定参数类型即可

template<typename F, typename... Args>
class Test<F(Args...)>

调用出需要指定不定参数的类型和数量

Test<int(int, int, int)> test(TestFunction);//实例化模板

5、模板类传入不定参数的C++成员函数指针

和之前的demo不同，这里将上文的 TestClass 模板类型

template<typename M, typename T>
class Test;
template<typename M, typename F, typename... Args>
class Test<M, F(Args...)>
{
public:
  typedef F(M::*TestCallback)(Args...);

  explicit Test(M *ptr, TestCallback func)
    : ptr(ptr), testCallback(func)
  {
  }

  void exec()
  {
    (*ptr.*testCallback)(11, 22, 33);
  }
private:
  TestCallback testCallback;
  M *ptr;
};

需要执行的类方法

template<typename ...Args>
class TestClass
{
public:
  int TestFunction(Args... args)
  {
    std::list<int> arg_list = std::initializer_list<int>{args...};
    while (!arg_list.empty())
    {
      cout << arg_list.front() << endl;
      arg_list.pop_front();
    }
    return 0;
  }
};

调用处

template<typename... Args>
void func()
{
  using TC = TestClass<Args...>;
  TC testClass;
  Test<TC, int(Args...)> test(&testClass, &TC::TestFunction);
  test.exec();
}

int main()
{
  func<int, int, int>();//实例化

  return 0;
}