C++ 11（2）

 1.可变模板参数

在 C++ 泛型编程中，“处理任意数量、任意类型的参数” 是一个常见需求。

传统模板只能固定参数数量和类型，面对可变场景时往往需要大量重载，代码冗余且扩展性差。

而 C++11 引入的可变模板参数（Variadic Templates） 彻底解决了这一问题，它允许模板接受 “任意数量、任意类型” 的参数，为泛型编程提供了极大的灵活性。

一、什么是可变模板参数？ 可变模板参数（简称 “可变参数”）是 C++11 新增的模板特性，允许模板定义中包含 “参数包”（Parameter Pack）—— 即零个或多个类型 / 值的集合。

其核心语法用 ... 表示，分为两种形式：

模板参数包：表示 “任意数量的类型参数”，语法为 typename... Args（或 class... Args）。

函数参数包：表示 “任意数量的函数参数”，语法为 Args... args（需与模板参数包对应）。

// 模板参数包Args：接受任意数量的类型
// 函数参数包args：接受任意数量、对应类型的参数
template <typename... Args>
void func(Args... args) {
    // ...
}

 这里的 Args 是 “模板参数包”（类型集合），args 是 “函数参数包”（值集合），两者通过 ... 关联，共同实现 “任意参数” 的传递。

2. 参数包的 “展开”：核心操作 可变参数的关键是 **“展开参数包”**—— 即把参数包中的元素逐个提取出来处理。由于参数包是 “打包” 的集合，直接使用 args 会编译错误，必须通过特定语法展开。常见展开方式有三种：

（1）递归展开（C++11 起支持） 通过 “递归函数 + 终止函数” 的组合，每次提取参数包的第一个元素，直到参数包为空。 示例：打印所有参数

// 终止函数：当参数包为空时调用
void print() {}

// 递归函数：提取第一个参数，剩余参数包继续递归
template <typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";  // 处理第一个参数
    print(rest...);  // 展开剩余参数包
}

// 调用：支持任意数量、任意类型的参数
print(1, "hello", 3.14, true);  // 输出：1 hello 3.14 1

 （2）折叠表达式（C++17 起支持） C++17 引入 “折叠表达式”，用 (args op ...) 或 (... op args) 直接展开参数包，无需递归，代码更简洁。】

示例：计算参数之和

template <typename... Args>
auto sum(Args... args) {
    return (... + args);  // 折叠表达式：从左到右累加所有参数
}

sum(1, 2, 3, 4);  // 结果：1+2+3+4=10
sum(1.5, 2.5, 3);  // 结果：1.5+2.5+3=7.0

（3）逗号表达式 + 初始化列表（C++11 起支持） 利用初始化列表的特性，通过逗号表达式逐个处理参数包元素（常用于 “无返回值” 的场景，如打印、存储）。

示例：将参数存入容器

#include <vector>
#include <any>  // C++17起支持

template <typename... Args>
std::vector<std::any> to_vector(Args... args) {
    std::vector<std::any> vec;
    // 逗号表达式：每次push_back一个元素，最终返回void
    (vec.push_back(args), ...);  // C++17折叠表达式简化写法
    return vec;
}

// 调用：存入不同类型的元素
auto vec = to_vector(1, "hello", 3.14);

比如像下面这个日期类 可变模板参数可以很好的帮我们实现灵活的构造 

class date
{
	public:
	date(int year=2005, int month=7, int day=12)
	:_year(year)
	,_month(month)
	,_day(day)
	{

	}
public:int _year;
	  int _month;
	  int _day;
};


template<class... Args>
date* create(Args... args)
{
	date* ret = new date(args...);
	return ret;
}



int main(void)
{
	date* p1 = create(1);
	date* p2=create(1, 2);
	date* p3=create(1, 2, 3);
	date* p4 = create(3);
	return 0;
}

2.emplace_back

 我们来看下面这段代码

class date
{
	public:
	date(int year=2005, int month=7, int day=12)
	:_year(year)
	,_month(month)
	,_day(day)
	{

	}
	date(date&& a)= default;
	date(date& a) = default;
	date(const date& a) = default;
public:int _year;
	  int _month;
	  int _day;
};




int main(void)
{
	list<date> it;
	it.push_back(date(1, 2, 3));
	it.emplace_back(date(1, 2, 3));
	//it.push_back(1, 2, 3); 不允许 error
	it.emplace_back(1, 2, 3);
	return 0;
}

为啥push_back做不到 emplaceback就能做到呢？

我们发现 push_back接收的参数是准确的类型

因此我们这个地方传参 要先将avl(实例化就是Date) 调用构造函数构造出来

再把val传给push_back去拷贝构造(或移动构造)list的节点

而emplace_back则是直接把参数包依次传下去 直接构造list的节点

对于自定义类型的深拷贝 这两个效率差不多 因为移动构造的效率影响很小很小

但是对于较大类型的浅拷贝 那效率就会有所差距 

 3.C++ 11新增的类的成员函数

C++11新增的两个成员函数 分别是动构造函数和移动赋值运算符

如果你没有自己实现移动构造函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任

意一个。

那么编译器会自动生成一个默认移动构造。

默认生成的移动构造函数，对于内置类

型成员会执行逐成员按字节拷贝，

自定义类型成员，则需要看这个成员是否实现移动构造，

如果实现了就调用移动构造，没有实现就调用拷贝构造。

如果你没有自己实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中

的任意一个，那么编译器会自动生成一个默认移动赋值。

默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，

自定义类型成员，则需要看这个成员是否实现移动赋

值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造

完全类似)

如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

当然简单一点的办法也有 那就是=default

4.=default

= default 是一种特殊的函数定义语法，用于显式指示编译器生成某个特殊成员函数的默认实现。

这些特殊成员函数包括：

默认构造函数（无参构造函数）

拷贝构造函数

拷贝赋值运算符

移动构造函数

移动赋值运算符

析构函数

当你在类中使用 = default 声明这些函数时，编译器会按照标准规则生成它们的默认实现，就像你没有显式声明这些函数一样。 

 5. function：统一回调接口的利器

std::function<返回类型(参数类型列表)>

需要包含头文件#include<function>

在现代 C++ 编程中，函数回调是一种常见的编程模式。

但 C++ 中的可调用对象形式多样，包括普通函数、函数指针、成员函数、lambda 表达式等，这使得统一处理这些可调用对象变得困难。

C++11 引入的 std::function 就是为解决这一问题而生的强大工具。 

什么是 std::function？

std::function 是一个通用的多态函数包装器，它可以存储、复制和调用任何可调用对象。

它的实例可以对任何可以调用的目标实体进行存储、复制和调用操作，

这些目标实体包括普通函数、Lambda 表达式、函数指针、以及其它函数对象等。

std::function 的类型是在编译时确定的，但它可以在运行时存储和调用不同类型的可调用对象，为回调机制提供了统一的接口。 

// 普通函数
int add(int a, int b) {
    return a + b;
}

// 函数对象类
struct Subtract {
    int operator()(int a, int b) const {
        return a - b;
    }
};

int main() {
    // 存储普通函数
    std::function<int(int, int)> func1 = add;
    std::cout << "add: " << func1(5, 3) << std::endl;

    // 存储函数对象
    std::function<int(int, int)> func2 = Subtract();
    std::cout << "subtract: " << func2(5, 3) << std::endl;

    // 存储lambda表达式
    std::function<int(int, int)> func3 = [](int a, int b) {
        return a * b;
        };
    vector <function<int(int, int)>> s1 = { func1,func2,func3 };

    return 0;
}

比如说像这段代码 我想把仿函数 lambda 普通函数 全部存在vector里面

再比如说我们看下面这道题 就可以这样些了

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string, function<int(int, int)>> opFuncMap =
        {
        { "+", [](int i, int j) {return i + j; } },
        { "-", [](int i, int j) {return i - j; } },
        { "*", [](int i, int j) {return i * j; } },
        { "/", [](int i, int j) {return i / j; } }
        };
        for (auto& str : tokens)
        {
            if (opFuncMap.find(str) != opFuncMap.end())
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                st.push(opFuncMap[str](left, right));
            }
            else
            {
                // 1、atoi itoa
                // 2、sprintf scanf
                // 3、stoi to_string C++11
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

 6.bind ：灵活调整和绑定可调用对象

callable 是要绑定的原始可调用对象（函数、函数指针、成员函数指针、函数对象等）

arg1, arg2, ..., argN 是传递给 callable 的参数，可以是值、引用，也可以是占位符

占位符是 std::placeholders 命名空间中的对象，如_1、_2、_3 等，

它们表示新可调用对象的第几个参数。例如，_1 表示新可调用对象的第一个参数，_2 表示第二个参数，依此类推。

// 普通函数
int add(int a,int rate, int b) {
    return (a + b)*rate;
}

int main() {
    // 绑定add函数，固定第一个参数为10
    auto addTen = std::bind(add,placeholders::_2,20, placeholders:: _1);
    //addTen(1,2);中的第一个参数始终传给传给placeholders:: _1
    //第二个参数始终传给placeholders:: _2
    //然后bind函数三个参数按照顺序传给add函数
    //也就是placeholders::_2传给a
    // 20传给rate
    // placeholders:: _1传给b
    cout<<addTen(1, 2)<<endl;
    // 
    // 调整参数顺序
    auto subtract = std::bind(add, 30,placeholders::_2, placeholders::_1);
    //subtract(1,2);中的第一个参数(2)始终传给传给placeholders:: _1
//第二个参数(3)始终传给placeholders:: _2
     //然后bind函数三个参数按照顺序传给add函数
 //也就是30传给a
 //placeholders::_2传给rate
 // placeholders:: _1传给b
    cout<<subtract(2, 3)<<endl;

    return 0;
}

但是对于类成员函数 还是有些需要注意的哈

class A
{
public:
    static int sub1(int a, int b)
    {
        return a - b;
    }
public:
    int sub2(int a, int b)
    {
        return a - b;
    }
};
int main() {
    // 绑定add函数，固定第一个参数为10
    auto addTen = std::bind(A::sub1,placeholders::_2, placeholders:: _1);
    //对于非静态成员函数取地址要＋一个& 但是静态成员函数可加可不加
    auto addTen1 = std::bind(&A::sub1, placeholders::_2, placeholders::_1);
    cout << addTen(1, 2) << endl << addTen1(1, 2) << endl;



    // 对于普通成员函数
    A st;
    //直接传对象可以
    auto subtract = std::bind(&A::sub2,st, placeholders::_2, placeholders::_1);
    //传匿名对象也可以
    auto subtract1 = std::bind(&A::sub2, A(), placeholders::_2, placeholders::_1);
    //传对象的地址也可以
    auto subtract2 = std::bind(&A::sub2, &st, placeholders::_2, placeholders::_1);
    //这个地方不能传匿名对象的地址 因为匿名对象是右值 不能取地址！！！
    cout << subtract(2, 3) << endl << subtract1(2, 3) << endl << subtract2(2, 3) << endl;
    return 0;
}