c++11学习笔记（8）- 可变参数宏、函数、模板

原创

2022-11-23

4509

c++11 可变参数模板可变参数宏定义可变参数函数

文章目录

3.2 可变参数模板的展开 - 非递归展开

3.3 一个函数代理类的实例

1. 可变参数宏

可变参数的宏在C语言中就有定义，使用 …，在宏定义中表示可变参数；使用 VA_ARGS 替代宏定义中的可变参数。比如我们想要定义 printf() 函数为宏 PR，下面是一个简单的例子：

// 宏定义PR为printf函数
#ifndef PR
#define PR(pStr, ...) \
    printf(pStr, __VA_ARGS__);
#endif

int main(int argc, char** argv){
    PR("%d, %d\n", 10, 20)
}

函数的运行结果为：
10，20

2. 可变参数函数

下面是一个求和的一个函数

int getSum(int count, ...){
    va_list ap;
    int sum = 0;
    va_start(ap, count);
    for (int i = 0; i < count; ++i)
        sum += va_arg(ap, int);
    va_end(ap);
    return sum;
}

int main(int argc, char** argv) {
    std::cout << getSum(3, 1, 2, 3) << std::endl;
    std::cout << getSum(5, 1, 2, 3, 4, 5) << std::endl;
}

上面程序运行结果为：
6
15

这是一个求和函数，函数中count表示参数的个数；va_list 类型的ap用来辅助获取参数。这里首先使用函数 va_start() 对ap进行初始化，使ap变成了一个边长参数的句柄；然后使用函数 va_arg() 将参数一一取出进行运算；最后使用函数 va_end() 结束操作。

3. 可变参数模板

使用可变参数模板时，在 typename 或者 class 后面加上三个点（…）表示可变参数模板。使用sizeof… 可以获取参数的个数; 下面是一个简单的例子

template<typename... T>
void f(T... args){
    std::cout << sizeof...(args) << std::endl;
}

int main(int argc, char** argv) {
    f(1, 2);
    f(1, 2, 3);
    f(1, 2, "aaa", 20.5);
}

程序的输出结果为
2
3
4

3.1 可变参数模板的展开 - 递归展开

关于可变参数模板的展开有两种方式，一种是递归形式的展开；必须要定义一个终止函数，如下面的程序：

template<typename T>
void func(T t){	// 终止函数
    std::cout << t << std::endl;
}

template<typename T, typename... Args>
void func(T head, Args... args){
    std::cout << head << std::endl;
    func(args...);
}

int main(int argc, char** argv){
    func(1, 2, 3, 4, 5);
}

终止函数是为了递归终止时使用的，上面的代码展开为：
func(1, 2, 3, 4, 5);
func(2, 3, 4, 5);
func(3, 4, 5);
func(4, 5);
当递归到func(4, 5)时，head传递4，调用已经具化的函数func(5)。

可以简单写一个求和的模板函数：

template<typename T>
T sum(T t){
    return t;
}

template<typename T, typename... Args>
T sum(T head, Args... args){
    return head + sum(args...);
}

int main(int argc, char** argv){
    std::cout << sum(1, 2, 3, 4, 5) << std::endl;
}

上面的的程序运行结果为：
15

3.2 可变参数模板的展开 - 非递归展开

可以使用初始化参数列表的形式展开函数模板，首先看一下下面的代码：

template<typename T>
void printTag(T t){
    std::cout << t << std::endl;
}

template<typename... Args>
void expand(Args... args){
    int array[] = { (printTag(args), 0)... };
}

int main(int argc, char** argv){
    expand(1, 2, 3, 4, 5);
}

上面的代码展开为：
int array[] = { (printTag(1), 0), (printTag(2), 0), (printTag(3), 0), (printTag(4), 0), (printTag(5), 0) };

同理也可以使用初始化参数列表的形式：

template<typename Func, typename... Args>
void expandFunc(const Func& f, Args... args){
    std::initializer_list<int>{(f(std::forward<Args>(args)), 0)...};
}

int main(int argc, char** argv) {
    expandFunc([](int i){std::cout << i << std::endl; }, 1, 2, 3);
}

这里使用的 std::forward 实现完美转发，关于完美转发可参考这篇文章
c++11学习笔记（5）- 引用折叠和完美转发
lambda表达式传递Func，参数1，2，3分别调用该lambda表达式。

3.3 一个函数代理类的实例

我们要实现一个函数代理类，这个类的用法如下：

class TestFuncObject
{
public:
    int runFunc1(int a, int b){
        return a + b;
    }
    int runFunc2(int a, int b, int c){
        return a + b + c;
    }
}

int main(int argc, char** argv){
    TestFuncObject o;
    
    auto  f1 = createDelegate(&o, &TestFuncObject::runFunc1);
    std::cout << f1(10, 20) << std::endl;
    
    auto  f2 = createDelegate(&o, &TestFuncObject::runFunc2);
    std::cout << f2(10, 20, 30) << std::endl;
}

函数 createDelegate 创建一个代理类，然后直接使用该代理函数就可完成被代理函数。
函数的运行结果为：
30
50

下面时代理函数和代理类的具体实现：

template<typename T, typename R, typename... Args>
class MyDelegate{
public:
    MyDelegate(T* t, R (T::*f)(Args...)) :m_t(t), m_f(f){}
    
    R operator()(Args... args){
        return (m_t->*m_f)(std::forward<Args>(args)...);
    }

private:
    T* m_t;
    R (T::*m_f)(Args...);
};

template<typename T, typename R, typename... Args>
MyDelegate<T, R, Args...> createDelegate(T* t, R(T::*f)(Args...)){
    return MyDelegate<T, R, Args...>(t, f);
}

MyDelegate 为代理类，重载了()，为一个仿函数。m_t为对象指针，m_f为该对象的函数指针。createDelegate 为代理函数。