C++的回调函数和可变参数函数

      讲一些什么吧，今天终于不用加班了，可以有空来看csdn，上次写csdn还是上次的时候，可能写的不太工整，看的人好少啊。再坚持坚持吧，总有一天会有人看到的，不然用来给自己回顾也行，今天随便记一点用法，回调跨类使用的回调函数，还有C++11特性可变参数。

回调函数

        c++本是面向对象的语言，本人很少使用回调，更多的是用多态让同一系列的对象做差异性行为。但可以不用，不能不会，总有一天应该会派上用场。

//声明一个回调函数指针类型
typedef int(*pMyCountFunction)(int，int);

//定义一个加法函数
int add(int a , int b)
{
    return a+b;
}

int main(int argc, char *argv[])
{
    //对回调函数指针进行赋值
    pMyCountFunction m_func = add;
    
    //调用函数指针
    m_func(10,20);
    return 0;
}

        突然有一个想法，如果想在一个类中用另一个类的成员函数，使用函数指针怎么办？但好像如果两个类的函数都是公用的也没必要，可以直接包含另一个类的对象然后直接调用，但是有问题就有答案，让我来研究一下跨类使用函数指针怎么弄。

//============================================================================
//==========================这是一个头文件=====================================
#ifndef COBJECTA_H
#define COBJECTA_H

class CObjectA
{
public:
    CObjectA();
    int addA(int a,int b);
};

//类内的函数，注意得再指针类型名左边加一个作用域，这个指针名专门用来传递指定类内的成员方法

typedef int(CObjectA::*PtrAddA)(int a, int b);
class CObjectB
{
public:
    CObjectB();
    int costumAddFuc(int a , int b);
private:
    PtrAddA m_func;
    CObjectA *m_boja;
};

#endif // COBJECTA_H


//============================================================================
//==========================这是一个cpp实现文件=================================


#include "cobjecta.h"

CObjectA::CObjectA()
{

}

int CObjectA::addA(int a, int b)
{
 return a+b;
}

CObjectB::CObjectB()
{
     m_boja = new CObjectA;
     m_func = nullptr;
}

int CObjectB::costumAddFuc(int a, int b)
{
   if(!m_func)
   m_func = m_boja->addA;

  // 这里的用法很特别 ->*  或 .* 否则会报错
   return (m_boja->*m_func)(a,b);
}
//==============================================================================
#include "cobjecta.h"
int main(int argc, char *argv[])
{
    CObjectB b;
    cout()<< b.costumAddFuc(10,20);
    return 0;
}

// 结果输出
// 30

可变参数

        不会吧，不会吧，都已经C++24了还有人没用过可变参数吧！哈哈哈，快来和我一起看一看吧。

C++11的可变形参提供了两种使用场景：
  1.个数未知，但所有类型相同
  2.类型可能不同，可变参数模板

 个数未知，但所有类型相同：

int count(int count ,...)
{
    if(count<=0) return 0 ;
    int temp = 0;
    //va_list类型是在cstdarg头文件里面定义的，该指针用来依次
    va_list arg_ptr;
    va_start(arg_ptr,count);
    for(int idx=0;idx<count;++idx)
    {
        //va_arg是一个宏，返回arg_ptr指向的参数位置，并使arg_ptr递增来指向下一个参数值
        //va_arg宏的第二个参数是需要统计的第一个参数的类型，如果类型不正确，程序也可能会执行，但得到的是无用的数据，arg_ptr将被错误地递增
        temp+=va_arg(arg_ptr,int);
    }
    //将va_list类型的指针复位成空值就是清空可变参数列表
    va_end(arg_ptr);
    return temp;
}

int main(int argc, char *argv[])
{
    qDebug()<<count(3,1,2,3);
    return 0；
}

//结果
//6

类型可能不同，可变参数模板：

//这个例子用来说明sizeof ... 的用法
template <typename T,typename... Args>
void funcTest1(const T &t,const Args&...rest)
{
    qDebug()<<sizeof(T)<<sizeof...(Args)<<sizeof...(rest);
}

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

    funcTest1(5,3,4,5,6,7);

    return 0;
}

//输出
// 4 5 5

template <typename T>
void funcTest2(const T &t)
{
    qDebug()<<t;
}

template <typename T,typename... Args>
void funcTest2(const T &t,const Args&...rest)
{
    qDebug()<<"======"<<t<<"======";
    funcTest2(rest...);
}


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

    funcTest2(3,"hello","world",44);
    return 0;
}

//输出
//====== 3 ======
//====== hello ======
//====== world ======
//44

总结：

        今天就这样吧，最后对一件工作抱有持续的求知欲是比较难做到的，不忘初心，砥砺前行，也需要顺应时势，顺势而为。加油吧，朋友们！