C++模板从入门到入土

#include <iostream>
using namespace std;

double func1(double a, double b) {
    return a + b;
}

template<class T>
T funcT1(T a, T b) {
    return a + b;
}

template<class T>
void funcT2() {
    cout << "funcT2" << endl;
}

template<class T1, class T2, class T3>
T3 funcT3(T1 a, T2 b) {
    return a + b;
}

template<class T3, class T1, class T2>
T3 funcT4(T1 a, T2 b) {
    return a + b;
}

/*
 * 函数模板的调用方式
 * funcT1(a,b)  这种是编译器根据参数推导类型
 * funcT1<>(a,b)  <>为空此种情况下，也是编译器根据参数推导类型，<>此处无用，但是<>有其它的用处
 * */

int main() {

    int a = 1;
    int b = 2;
    double c = 1.1;
    double d = 2.2;
    char e = 'e';
    string f = "f";

    cout << funcT1(a, b) << endl;//调用模板函数
    cout << funcT1<>(a, b) << endl;//调用模板函数
    //cout << funcT1(a,c) << endl;//这种写法，传了两个不同类型的参数，编译器无法推导用哪种类型，在函数模板里面，无法进行隐式类型转换
    cout << funcT1<int>(a, c) << endl;//但是可以显式指定类型,调用模板函数
    cout << funcT1<double>(a, c) << endl;//要么告诉编译器是什么类型，要么让其自动推导，但是要保证同一个类型参数的数据类型必须一样

    //funcT2();//虽然在函数中没有使用到类型参数，但是也必须得告诉编译器，这里要调用的是函数模板
    funcT2<int>();//因为没有参数，所以编译器就没办法根据参数推导出类型，所以必须得强制指定

    //cout << funcT3(a,b)<<endl;//这种写法，有三个类型参数，但是只传了两个值，所以编译器无法推导出最后一个类型
    cout << funcT3<int, int, int>(a, b) << endl;

    cout << funcT4<int>(a, b) << endl;//此处，第一个类型参数要指定，第二个，第三个，可以由编译器自动推导

    cout << func1(a, e) << endl;//普通函数可以进行隐式类型转换


    return 0;
}

#include <iostream>
using namespace std;

/*
 *
 * 函数模板与普通函数的重载
 * 当调用规则同时满足普通函数与函数模板时，优先调用普通函数
 *
 *
 * 函数模板与函数模板的重载
 *
 * */

int func1(int a, int b) {
    cout << "这是普通函数 func1" << endl;
    return a + b;
}

template<class T>
T func1(T a, T b) {
    cout << "这是函数模板 func1" << endl;
    return a + b;
}


void func2() {
    cout << "这是普通函数 func2" << endl;
}

template<class T>
void func2() {
    cout << "这是函数模板 func2" << endl;
}

template<class T>
void func3(T a, T b) {
    cout << "这是函数模板 func3" << endl;
}

template<class T>
void func3(T* a, T* b) {
    cout << (a + b) << endl;
    cout << "这是函数模板 *func3" << endl;
}

template<class T>
void func4(T a, T b) {
    cout << "这是函数模板 func4-两个参数" << endl;
}
template<class T>
void func4(T a) {
    cout << "这是函数模板 func4-一个参数" << endl;
}

int main() {

    int a = 1;
    int b = 2;

    double c = 1.1;
    double d = 2.2;

    func1<>(a, b);

    func1(a, b);
    func1<int>(a, b);//非要调用函数模板 <类型>
    func1<>(a, b);//也是要强制调用函数模板，这里可以用后面的参数推导出类型
    func1(c, d);

    func2();//这样子是调用普通函数
    func2<int>();//这样子是调用函数模板,因为没有参数，所以编译器没办法通过参数来推导类型，所以如果要调用此函数模板，必须显式指定类型

    func3(a, b);
    //func3(&a, &b);//当调用函数模板时，如果函数体内不支持类型的运算，就会报错，cout << (a + b) << endl;

    func4(a);
    func4(a, a);

    return 0;
}

#include <iostream>
using namespace std;

/*
 * 函数模板类型参数类型默认值
 *
 * 函数模板类型参数默认值
 * */

//指定类型和值
template<class T1, class T2 = int>//这里表示的是类型参数的默认值
void funcT1(T1 a, T2 b = 123) {//这里表示的是函数中T2类型的参数的默认值
    cout << a << "--" << typeid(a).name() << endl;
    cout << b << "--" << typeid(b).name() << endl;
}


//指定类型
template<class T1 = int, class T2>
void funcT2(T2 b) {
    T1 a = b;
    cout << b << "--" << a << endl;
}

//指定值
//只有一部份类型的数据支持这种写法，整型，枚举，指针
template<class T1, int T2 = 12> //这种写法，int 不能改了，只参在函数里面传值
void funcT3(T1 a) {
    cout << a << "--" << T2 << endl;
}


int main() {

    int a = 1;
    int b = 2;
    double c = 1.1;
    double d = 2.2;

    funcT1(a);

    funcT2(c);//这里有个强转，类型参数T1用的是默认值int
    funcT2<double>(c);//这里是显式指定类型参数T1的值

    funcT3(a);
    //这种写法，不支持变量,只能用常量，因为这个值要在编译的时候就确定，而不是运行的时候确定
    int const x = 789;
    funcT3<int, x>(a);//x 是常量，可以

    return 0;
}

#include <iostream>
using namespace std;


template<class T1, class T2>
void funcT1(T1 a, T2 b) {
	cout << "这里是函数模板funcT1" << endl;
}

//函数模板特化--这里是所有类型参数都特化，称之为全局特化
template<>
void funcT1<int, double>(int a, double b) {
	cout << "这里是函数模板特化-int--double--funcT1" << endl;
}

//函数模板不支持局部特化,在类模板中还是支持的，后面讲
//如果非要达到这种效果，可以用重载或者是类型参数默认值
//https://zhuanlan.zhihu.com/p/268600376
//http://www.gotw.ca/publications/mill17.htm
//https://www.thinbug.com/q/1416345

// 函数模板偏特化demo
//template <typename A, typename B>
//void f(A a, B b) {
//	cout << "Normal version." << std::endl;
//}
//
//template <typename A>
//void f<A, int>(A a, int b) {
//	cout << "Partial version." << std::endl;
//}

template<class T1 = int, class T2>
void funcT1(int a, T2 b) {
	cout << "这里是函数局部模板特化-int--double--funcT1" << endl;
}

void funcT1(int a, double b) {
	cout << "这里是函数重载-int--double--funcT1" << endl;
}


//泛化特化的概念是相对的，默认的函数模板(没有默认值的情况下)都是泛化
//优先级  1 普通函数；   2 特化版函数模板；   3 泛化版函数模板


int main() {
	int a = 1;
	int b = 2;
	double c = 1.1;
	double d = 2.2;
	funcT1(a, b);//int,int
	funcT1(c, d);//double,double
	funcT1(a, c);//int,double-------特化
	funcT1(c, a);//double,int

	//f(a, a);

	return 0;
}

#include <iostream>
#include<string>
using namespace std;

//非模板类
class C1 {
public:
	C1(int id, string name) {
		this->id = id;
		this->name = name;
	}
	~C1() {}
	void show() {
		cout << id << "--" << name << endl;
	}
	static void func1() {
		cout << "这里是 c1-func1" << endl;
	}
	int id;
	string name;

};


//类模板
template<class T1, class T2>
class C2 {
public:
	C2(T1 id, T2 name) {
		this->id = id;
		this->name = name;
	}
	~C2() {}
	void show() {
		cout << id << "--" << name << endl;
	}
	static void func1() {
		cout << "这里是 c2-func1" << endl;
	}
	T1 id;
	T2 name;
};


//类模板默认值
//默认值要放在最后面
//template<class T1=int, class T2> //报错
template<class T1 = int, class T2 = string>
//template<class T1,class T2=string>
class C3 {
public:
	C3(T1 id = 456, T2 name = "jerry") {
		this->id = id;
		this->name = name;
	}
	~C3() {}
	void show() {
		cout << id << "--" << name << endl;
	}
	static void func1() {
		cout << "这里是 c2-func1" << endl;
	}
	T1 id;
	T2 name;
};


int main() {

	C1 c1(123, "tom");
	c1.show();
	c1.func1();
	C1::func1();


	//类模板中无法根据参数值来推导类型变量，要显示指定
	//实例化方式和成员方法调用跟非类模板中一样，只是要指定类型参数的值

	C2<int, string>c2(123, "tom");
	c2.show();
	c2.func1();
	C2<int, int>::func1();


	C3<int, int>c3(123, 456);
	c3.show();

	C3<string, string>c4("tom", "tom");
	c4.show();

	C3<>::func1();

	return 0;
}

#include <iostream>
#include<string>
using namespace std;

template<class T1, class T2>
class C1 {
public:
    C1(T1 id, T2 name) {
        this->id = id;
        this->name = name;
    }
    T1 id;
    T2 name;
};

/*
 * 从c++17开始，支持类模板的自动推导
 *
 * */

 //有参构造自动推导
template<class T1, class T2>
class C2 {
public:
    C2(T1 id, T2 name) {
        this->id = id;
        this->name = name;
    }
    T1 id;
    T2 name;
};

//没有构造函数自动推导
template<class T1, class T2>
class C3 {
public:
    T1 id;
    T2 name;
};

//自定义推导规则
template<class T1, class T2>
class C4 {
public:
    T1 id;
    T2 name;
};
template<class T1, class T2>
C4(T1, T2)->C4<T1, T2>;

//结构体也支持自定义推导
template<class T1, class T2>
struct S1 {
    T1 id;
    T2 name;
};
template<class T1, class T2>
S1(T1, T2)->S1<T1, T2>;


int main() {

    C1<int, string> c1(123, "tom");
    cout << c1.id << "--" << c1.name << endl;

    C2 c2(123, "tom");
    cout << c2.id << "--" << c2.name << endl;

    //无构造函数，要显式指定
    C3<int, string>c3;
    c3.id = 123;
    c3.name = "tom";
    cout << c3.id << "--" << c3.name << endl;

    //加自定义推导规则
    C4 c4{ 123,"tom" };
    cout << c4.id << "--" << c4.name << endl;

    S1 s1{ "tom","tom" };
    cout << s1.id << "--" << s1.name << endl;

    return 0;
}

#include <iostream>
using namespace std;

template<class T1, class T2>
class C1 {
public:
    C1(T1 id, T2 name) {
        this->id = id;
        this->name = name;
    }

    void func1() {
        cout << "func1" << endl;
    }
    static void func2() {
        cout << "static func2" << endl;
    }

    T1 id;
    T2 name;
};

/*
 * 如果没有实例化，则不会编译类模板，被编译器优化掉了，认为是无效代码
 * 如果有实例化，只会编译出对应的参数类型的代码，相央类型参数的，只会编译一份
 * 如果成员函数没有被调用，则也不会编译出来
 *
 * 本质上来讲，跟普通类编译的规则是一致的，只不过会有多份代码，每种有使用的类型都会编译一份
 *
 * */

int main() {

    C1<int, int>c1(123, 456);
    c1.func1();
    C1<double, double> c11(1.1, 1.1);
    c11.func2();

    return 0;
}

#include <iostream>
#include<string>
using namespace std;

//template<class T1,class T2>//没有默认值
//template<class T1=int,class T2=string>//全部默认值

//部份参数默认值的情况下，第一个有默认值的参数后面的所有参数，都要有值
//template<class T1 = int, class T2>//部份默认值 错误
template<class T1, class T2 = string>//部份默认值
class C1 {
public:
	C1(T1 id, T2 name) {
		this->id = id;
		this->name = name;
	}
	T1 id;
	T2 name;
};


//局部特化--类型参数不能加默认值
template<class T1>
class C1<T1, string> {
public:
	C1(T1 id, string name) {
		this->id = id;
		this->name = name;
		cout << "这里是局部特化" << endl;
	}
	T1 id;
	string name;
};



//默认值引用，后面的变量从前面变量中取值
template<class T1, class T2 = T1*>
class C2 {
public:
	C2(T1 id, T2 name) {
		this->id = id;
		this->name = name;
	}
	T1 id;
	T2 name;
};


//类模板在时候声明的时候给类型默认值
template<class T1 = int, class T2 = int>
class C3 {
public:
	C3(T1, T2);
	T1 id;
	T2 name;
};

template<class T1, class T2>
C3<T1, T2>::C3(T1 id, T2 name) {
	this->id = id;
	this->name = name;
}


template<class T1, class T2, class T3 = int>
struct S1;

template<class T1, class T2 = int, class T3>
struct S1;

template<class T1, class T2, class T3>
struct S1 {
	T1 id;
	T2 name;
	T3 sex;
};

int main() {

	C1<int, string>c1(123, "tom");//没有默认值，显示指定类型

	//C1<>c11(123, "tom");//全部参数默认值，错误

	C1<int>c111(123, "tom");//部份参数默认值

	C1<int>c1111(123, "tom");

	cout << c1111.id << "--" << c1111.name << endl;

	int a = 123;
	C2<int>c2(a, &a);
	cout << c2.id << "--" << c2.name << endl;

	//类模板在声明的时候给类型参数默认值
	C3<>c3(1.1, 2.2);
	cout << c3.id << "--" << c3.name << endl;

	S1<int>s1;
	s1.id = 1;
	s1.name = 2;
	s1.sex = 3;
	cout << s1.id << "--" << s1.name << "--" << s1.sex << endl;

	return 0;
}

#include <iostream>
#include<string>
using namespace std;


//泛化
template<class T1, class T2>
class C1 {
public:
    C1() {
        cout << "这里是C1-构造" << endl;
    }
    void func1() {
        cout << "这里是C1-func1" << endl;
    }

    static int flag;

};
template<class T1, class T2>
int C1<T1, T2>::flag = 123;



//成员函数特化
template<>//全特化
void C1<int, int>::func1() {
    cout << "这里是C1-func1-全特化-int-int" << endl;
}

//成员变量全特化
template<>
int C1<double, double>::flag = 456;

//成员变量也不支持独立半特化
/*
template<class T1>
int C1<T1, double>::flag=789;
*/

//成员函数不支持独立半特化
/*
template<class T1>//半特化
void C1<T1, int>::func1() {
    cout<<"这里是C1-func1-半特化-T1-int"<<endl;
}
 */

//如果用相同的条件对成员函数或成员变量进行了特化，则无法再用此条件对类模板进行全特化
//比如void C1<int, int>::func1()，再class C1<int, int>就会报错


//整个类模板全特化--这里相对于泛化版来讲，完全是两个独立的类，除了名字一样，其它都是不一样的，
//可以有自己的在员方法和变量
template<>
class C1<int, string> {
public:
    C1() {
        cout << "这里是C1-全特化-构造" << endl;
    }
    void func1() {
        cout << "这里是C1-全特化-func1" << endl;
    }
    void func2() {
        cout << "这里是C1-全特化-func2" << endl;
    }
};


//半特化-参数个数半特化
template<class T1>
class C1<T1, string> {
public:
    C1() {
        cout << "这里是C1-半特化-T1-string-构造" << endl;
    }
    void func1() {
        cout << "这里是C1-半特化-T1-string-func1" << endl;
    }

    void func2() {
        cout << "这里是C1-半特化-T1-string-func2" << endl;
    }
};

//参数范围特化
template<class T1, class T2>
class C1<const T1, T2*> {
public:
    C1() {
        cout << "这里是C1-参数范围特化-const T1-T2 *-构造" << endl;
    }
    
    void func1(){
        cout<<"这里是C1-半特化-T1-string-func1"<<endl;
    }

    void func2(){
        cout<<"这里是C1-半特化-T1-string-func2"<<endl;
    }
     
};


int main() {
    C1<int, string>c1;
    c1.func1();
    //cout << c1.flag << endl;//"flag": 不是 "C1<int,std::string>" 的成员
    cout << endl;
    C1<int, int>c11;
    c11.func1();

    C1<double, double>c111;
    cout << c111.flag << endl;//456


    C1<int, double>c123;//泛化
    c123.func1();


    C1<int, string>c112;//全特化
    c112.func1();
    c112.func2();

    C1<string, string>c1112;//半特化
    c1112.func1();
    c1112.func2();


    C1<const int, int*>c1111;
    c1111.func1();

    C1<string, int>c11122;
    c11122.func1();


    return 0;

}

这里是C1-全特化-构造
这里是C1-全特化-func1

这里是C1-构造
这里是C1-func1-全特化-int-int
这里是C1-构造
456
这里是C1-构造
这里是C1-func1
这里是C1-全特化-构造
这里是C1-全特化-func1
这里是C1-全特化-func2
这里是C1-半特化-T1-string-构造
这里是C1-半特化-T1-string-func1
这里是C1-半特化-T1-string-func2
这里是C1-参数范围特化-const T1-T2 *-构造
这里是C1-半特化-T1-string-func1
这里是C1-构造
这里是C1-func1

#include <iostream>
using namespace std;

template<class T1>
class C1 {
public:
	C1() {
		cout << "构造" << endl;
	}

	//函数模板成员方法-泛化
	template<class T2>
	void func2(T2 id) {
		cout << "func2-类内实现-泛化-T2-id-" << id << endl;
	}

	//函数模板成员方法声明-泛化
	template<class T3>
	void func3(T3 name);

	//在类内声明一个特化版-int
	void func3(int name);

	//在类内实现一个特化版-string
	void func3(string name) {
		cout << "func3-类内实现-特化-string-name-" << name << endl;
	}

	//在类内实现一个特化版-共用类模板的参数T1
	void func3(T1 name) {
		cout << "func3-类内实现-特化-T1-name-" << name << endl;
	}

	//类中的虚函数不能用类型参数模板 ?? 为什么不能用，后面再讲
        //https://blog.csdn.net/qq_35865125/article/details/109234801
	//template<class T4>
	//virtual void func4(T4 age){}

	//正确
	virtual void func4(int age) {}
	virtual void func5(T1 age) {} //?这里为什么可以?  因为在实例化这个类的时候，己经指定了T1的值，编译的时候就己经有值了，而不是调用的时候

};

//函数模板成员方法-类外实现-泛化
template<class T1>
template<class T3>
void C1<T1>::func3(T3 name) {
	cout << "func3-类外实现-泛化-T3-name-" << name << endl;
};

//在类外实现一个特化版-int
template<class T1>
void C1<T1>::func3(int name) {
	cout << "func3-类外实现-特化-int-name-" << name << endl;
};

int main() {

	C1<double>c1;
	c1.func2(123);
	c1.func3(1.23);
	c1.func3("123");//这里的 参数并没有被自动推导为string 类型，所以没调用string特化版，被推导成了const char *


	string str = "str";
	c1.func3(str);

	C1<char>c11;
	c11.func3('1');

	C1<float>c111;
	c111.func3(1.1f);

	return 0;
}

#include <iostream>
using namespace std;


class C1 {
public:
    C1() {
        cout << "这里是构造" << endl;
    }

    //自定义的拷贝构造怎么实现，不放这里
    C1(const C1& c2) {
        cout << "这里是拷贝构造" << endl;
    }

    C1& operator=(const C1& c2) {
        cout << "这里是拷贝符值运算符重载" << endl;
        return *this;
    }

};

template<class T1>
class C2 {
public:
    C2() {
        cout << "这里是构造" << endl;
    }

    //拷贝构造 函数板
    template<class T2>
    C2(const C2<T2>& c2) {
        cout << "这里是拷贝构造" << endl;
    }

    //也是可以特化的
    C2(const C2<float>& c2) {
        cout << "这里是拷贝构造-特化-float" << endl;
    }


    template<class T3>
    C2<T1>& operator=(const C2<T3>& c2) {
        cout << "这里是拷贝符值运算符重载" << endl;
        return *this;
    }

    int id;

};



int main() {

    //特化
    C2<float>c2F;
    C2<int>c2Int(c2F);


    C2<int>c2;
    c2.id=123;

    C2<int>c22(c2);//这里并没有调用拷贝构造，因为c22和c2 的T1 是一样的，在一样的情况下，会去调用系统提供的默认拷贝构造函数(按值拷贝)，而不会调用拷贝构造函数模板
    cout<<c22.id<<endl;//123

    C2<double>c222(c2);//这里才会调用拷贝构造函数模板,因为c222和c2 的T1 是不一样的
    cout<<c222.id<<endl;

    //类型一样，调用的是默认的赋值方法
    C2<int>c2222;
    c2222=c2;
    cout<<c2222.id<<endl;//123

    //类型不一样，才会调用模板
    C2<double>c22222;
    c22222=c2;

    C1 c1;
    C1 c11(c1);
    C1 c111;
    c111=c1;

    return 0;
}

这里是构造
这里是拷贝构造-特化-float
这里是构造
123
这里是拷贝构造
-858993460
这里是构造
123
这里是构造
这里是拷贝符值运算符重载
这里是构造
这里是拷贝构造
这里是构造
这里是拷贝符值运算符重载

#include <iostream>
using namespace std;

template<class T1>
class C1 {

public:
    void func1() {
        cout << "C1-T1-func1" << endl;
    }

    //C1泛化--C2类内泛化
    template<class T2>
    class C2 {
    public:
        void func1() {
            cout << "C1-T1---C2-T2-func1" << endl;
        }
    };

    //C1泛化--C2类内特化
    template<>
    class C2<int> {
    public:
        void func1() {
            cout << "C1-T1---C2-int-func1" << endl;
        }
    };

};

//C1-特化-double---C2 泛化
template<>
class C1<double> {
public:
    template<class T2>
    class C2 {
    public:
        void func1() {
            cout << "C1-double---C2-T2-func1" << endl;
        }
    };
};

//C1-特化-float---C2-特化-float

template<>
template<>
class C1<float>::C2<float> {
public:
    void func1() {
        cout << "C1-float---C2-float-func1" << endl;
    }
};

/*
template<>
class C1<float>{
public:
    template<>
    class C2<float>{
    public:
        void func1(){
            cout<<"C1-float---C2-float-func1"<<endl;
        }
    };
};
*/


int main() {

    C1<int>::C2<double>C1T1C2T2;
    C1T1C2T2.func1();

    C1<int>::C2<int>C1T1C2Int;
    C1T1C2Int.func1();

    C1<double>::C2<int>C1DoubleC2T2;
    C1DoubleC2T2.func1();

    C1<float>::C2<float>C1FloatC2Float;
    C1FloatC2Float.func1();

    return 0;
}

#include <iostream>
using namespace std;

template<class T2> class C2;
template<class T1>
class C1 {
    friend C2<int>;//特化版C2作类模板C1的类友元

    template<class T3> friend class C3;//泛化版的C3作类模板C1的类友元

    friend T1;//类型参数作类模板C1的类友元

    friend class C4;//普通类作类模板C1的类友元

private:
    int id;
};

template<class T2>
class C2 {
public:
    void func1() {
        C1<double>c1;
        c1.id = 123;
        cout << c1.id << endl;
    }
};

template<class T3>
class C3 {
public:
    void func1() {
        C1<double>c1;
        c1.id = 456;
        cout << c1.id << endl;
    }
};

class C4 {
public:
    void func1() {
        C1<C4>c1;
        c1.id = 789;
        cout << c1.id << endl;
    }

    void func2() {
        C1<int>c1;
        c1.id = 321;
        cout << c1.id << endl;
    }
};

/*
 * 1 特化版的类模板作另一个类模板的类友元
 * 2 泛化版的类模板作另一个类模板的类友元
 * 3 类型参数作类模板的类友元
 * 4 普通类作模板的类友元
 * */

int main() {

    C2<int>c2;//这里必须与C1中指定的frined 类型参数一致
    c2.func1();

    C3<int>c3Int;
    c3Int.func1();
    C3<double>c3Double;
    c3Double.func1();

    C4 c4;
    c4.func1();
    c4.func2();

    return 0;
}

#include <iostream>
using namespace std;

//template<class T1,class T2> void func1();
//template<class T3,class T4> void func2(T3,T4);

template<class CT>
class C1 {

    //friend void func1<int,double>();//特化版无参func1 作 类模板C1的 friend
    template<class T1, class T2> friend void func1();//泛化版无参 func1 作 类模板C1的 friend


    //friend void func2<int,int>(int,int);//特化版有参func2 作 类模板C1的 friend
    template<class T3, class T4> friend void func2(T3, T4);//泛化版有参 func2 作 类模板C1的 friend


    //其实编译后是个全局函数，与C1的作用域无关

    //A friend function may also be defined within a class template, in which case it is only instantiated
    //when it is actually used.This typically requires the friend function to use the class template itself in
    //the type of the friend function, which makes it easier to express functions on the class template that
    //can be called as if they were visible in namespace scope 
    friend void func3(C1<CT>& c1) {
        c1.id = 789;
        cout << c1.id << endl;
    }

private:
    int id;
};

template<class T1, class T2>
void func1() {
    C1<int>c1;
    c1.id = 123;
    cout << c1.id << endl;
}

template<class T3, class T4>
void func2(T3 a, T4 b) {
    C1<int>c1;
    c1.id = 456;
    cout << c1.id << endl;
}


int main() {
    func1<int, double>();
    func1<int, int>();

    func2(1, 2);// func2<int,int>(1,2);
    func2(1, 2.2);

    cout << endl;

    //如果func3 没有被调用，则编译的时候，C1类里面，不会有这个func3
    C1<int>c1;
    func3(c1);

    C1<double>c11;
    func3(c11);//这里与上面的func3 会编译出两份代码，因为参数和不一样

    return 0;
}

#include <iostream>
using namespace std;

//函数模板
template<class T1, class T2>
void func1(T1 a, T2 b) {
    cout << a << "--" << b << endl;
}


//递归出口函数
void func3() {
    cout << "这里结束递归" << endl;
}

//可变参函数模板
template<class T33, class ... T3>   //T3是类弄参数变量名 ... 修饰符,  有点类似于指针变量  *p   中的 *
void func3(T33 b, T3 ...a) {     //T3 表示类型  a 表示变量名   int *p ，只不过是，a 里面是多个值，这个就是可变的意思

    //参数个数
    cout << "剩余参数个数：" << sizeof...(T3) << "--" << sizeof...(a) << endl;  //sizeof... 是固定写法，专门用在可变参里面，c++11 开始引入

    /* 循环取值
    //取出所有参数值--只能用在相同类型的参里面
    int sum=0;
    for(auto val :{a...}){
        cout << val << endl;
        sum += val;
    }
    cout << sum << endl;
     */


    //买一个三只松鼠零食包，里面有瓜子，核桃，饼干...
    //参数包，里面有int,double,float,string,指针...
    //取值 --解包
    //递归取值(解包)

    //递归是啥 ？
    cout << b << endl;
    func3(a...);

}

/*
 * func3(1,2,3,4);
 *      func3(2,3,4);
 *          func3(3,4);
 *              func3(4);
                    func3(); ---- 这里结束递归
 *
 * */





int main() {

    func1(1, 2);

    func3(1, 2, 3, 4);//参数类型相同

    func3();
    func3(1);
    func3(1,2);
    func3(1,2.2,"3.3");
    func3(1,2.2,"3.3", nullptr);

    return 0;
}

1--2
剩余参数个数：3--3
1
剩余参数个数：2--2
2
剩余参数个数：1--1
3
剩余参数个数：0--0
4
这里结束递归
这里结束递归
剩余参数个数：0--0
1
这里结束递归
剩余参数个数：1--1
1
剩余参数个数：0--0
2
这里结束递归
剩余参数个数：2--2
1
剩余参数个数：1--1
2.2
剩余参数个数：0--0
3.3
这里结束递归
剩余参数个数：3--3
1
剩余参数个数：2--2
2.2
剩余参数个数：1--1
3.3
剩余参数个数：0--0
nullptr
这里结束递归

#include <iostream>
using namespace std;

//函数模板
template<class T1, class T2>
void func1(T1 a, T2 b) {
    cout << a << "--" << b << endl;
}

/*
//递归出口函数
void func3(){
    cout<<"这里结束递归"<<endl;
}
 */

//可变参函数模板
template<class T33, class ... T3>   //T3是类弄参数变量名 ... 修饰符,  有点类似于指针变量  *p   中的 *
void func3(T33 b, T3 ...a) {     //T3 表示类型  a 表示变量名   int *p ，只不过是，a 里面是多个值，这个就是可变的意思

    //参数个数
    cout << "剩余参数个数：" << sizeof...(T3) << "--" << sizeof...(a) << endl;  //sizeof... 是固定写法，专门用在可变参里面，c++11 开始引入


    //买一个三只松鼠零食包，里面有瓜子，核桃，饼干...
    //参数包，里面有int,double,float,string,指针...
    //取值 --解包
    //递归取值(解包)

    //递归是啥 ？
    cout << b << endl;
    if constexpr (sizeof...(a) > 0) { //c++17后引入的内容，表示如果还有参数，就继续调用，这种写法可以省掉递归出口函数
        func3(a...);
    }

}

/*
 *
 * 在编译的时候就编译出了所有的函数,
 * 这里的递归跟我们平时所说的递归是不一样的，实际上是编译了多个函数，而不是在执行的时候去反复自己调用自己
 *
 * 这种递归解包取参的方式，很难做复杂运算，这是由递归本身决定的，因为递归就是自己调用自己，一直做同一件事情，直到有出口，然后就结束
 *
 * 这里如果要求和，得每次把前面一次计算的结果都带着，或者用全局变量保存计算结果
 *
 * 后面会去讲把这些参数解出来之后怎么使用，  折叠表达式，元组编程
 *
 *
 * func3(1,2,3,4);------------------------------- <void func3<int, int, int, int>(int, int, int, int)>:
 *      func3(2,3,4);---------------------------- <void func3<int, int, int>(int, int, int)>:
 *          func3(3,4);-------------------------- <void func3<int, int>(int, int)>:
 *              func3(4);------------------------ <void func3<int>(int)>:
                    func3(); ---- 这里结束递归 ---- <func3()>:
 *
 * */





int main() {

    func1(1, 2);

    func3(1, 2, 3, 4);//参数类型相同

    return 0;
}

#include <iostream>
using namespace std;

template<class ...T1>
void func1(T1 ...a) {
    int sum = 0;
    for (auto val : { a... }) {
        cout << val << endl;
        sum += val;
    }
    cout << sum << endl;
}

int sum2 = 0;

template<class T2, class ...T3>
void func3(T2 a, T3 ...b) {

    sum2 += a;
    if constexpr (sizeof...(b) > 0) { //c++17后引入的内容，表示如果还有参数，就继续调用，这种写法可以省掉递归出口函数
        func3(b...);
    }
    else {
        cout << sum2 << endl;
    }
}


/*
 * 折叠表达式
 *
 * 一元折叠表达式-左折
 * (... 运算符 变量名)
 * a,b,c,d    (((a-b)-c)-d)   从左边开始运算
 *
 * 一元折叠表达式-右折
 * (变量名  运算符 ...)
 *a,b,c,d    (a-(b-(c-d)))   从右边开始运算
 *
 *
 * 二元折叠表达式-左折
 * (初始值 运算符 ... 运算符 变量名)
 * default,a,b,c,d    ((((default-a)-b)-c)-d)   从左边开始运算，初始值在最左边
 *
 * 二元折叠表达式-左折
 * (变量名 运算符 ... 运算符 初始值)
 * a,b,c,d,default    (a-(b-(c-(d-default))))   从右边开始运算，初始值在最右边
 *
 * */

template<class ...T4>
void func4(T4 ...a) {
    cout << (... - a) << endl;   //(1,2,3,4)    (((1-2)-3)-4)   -8
    cout << (a - ...) << endl;     //（1,2,3,4)   (1-(2-(3-4)))   -2

    (cout << ... << a);
    cout << endl;
}

template<class ...T5>
void func5(T5 ... a) {
    cout << (10 - ... - a) << endl;  //(10,1,2,3,4)     ((((10-1)-2)-3)-4)      0
    cout << (a - ... - 10) << endl;    //(1,2,3,4,10)     (1-(2-(3-(4-10))))      8
}


int main() {

    func4(1, 2, 3, 4);

    func5(1, 2, 3, 4);

    func1(1, 2, 3, 4);
    func3(1, 2, 3, 4);

    return 0;
}

-8
-2
1234
0
8
1
2
3
4
10
10

#include <iostream>
using namespace std;

template<class ...T2>
void func2(T2 ...a) {
	cout << (... + a) << endl;
}

template<class ...T1>
void func1(T1 ...a) {
	cout << (... + a) << endl;   //10

	func2(2 * a...); //2,4,6,8    20 这种写法就是可变参表达式   逐项运算，再当参数包传给func2
	//func2(a... * 2);
	//func2(a... * a...);

	func2(1 + a...); //2,3,4,5    14

}

int main() {

	func1(1, 2, 3, 4);//每个参数*2 再求和

	return 0;
}

#include <iostream>

using namespace std;

template<class ...T1>
class C1 {
public:
    C1() {
        printf("C1--T1\n");
    }
};

template<class T2, class ...T3>
class C1<T2, T3...> : private C1<T3...> {
public:
    C1() {
        printf("C1--T2--T3--%s--%d\n", typeid(T2).name(), sizeof...(T3));
    }
};

/*
 *
 * 递归继承解包的过程
 *
 * class C1<int,double,float>:private C1<double,float>{}
 *
 *      class C1<double,float>:private C1<float>{}
 *
 *          class C1<float>:private C1<>{}
 *
 *              class C1{}
 *
 *
 * 递归    先递   再归
 *
 *
 * */


int main() {

    C1<int, double, float>c1;

    return 0;
}

#include <iostream>

using namespace std;

template<class ...T1>
class C1 {
public:
    C1() {
        printf("C1--T1--组合\n");
    }
};

template<class T2, class ...T3>
class C1<T2, T3...> {
public:
    C1() {
        printf("C1--T2--T3--%s--%d\n", typeid(T2).name(), sizeof...(T3));
    }

    C1<T3...>c1;
};

/*
 *
 * 递归组合解包的过程
 *
 * class C1<int,double,float>{
 *
 *      class C1<double,float>{
 *
 *              class C1<float>{
 *
 *                  class C1{
 *
 *                  }
 *              }
 *
 *      }
 *
 * }

 *
 *
 *
 * */


int main() {

    C1<int, double, float>c1;

    return 0;
}

#include <iostream>
using namespace std;

class Father {
public:
    virtual void say() {}

    virtual ~Father() {}

};

class Son1 : public Father {
public:
    virtual void say() {
        cout << "son1" << endl;
    }
};

class Son2 : public Father {
public:
    virtual void say() {
        cout << "son2" << endl;
    }
};



class Son3 {
public:
    void say() {
        cout << "son3" << endl;
    }
};

class Son4 {
public:
    void say() {
        cout << "son4" << endl;
    }
};


template<class T1>
void func1(T1& son) {
    son.say();
}


/*
 *
 * 模板里面的多态，并不需要继承，也没有虚函数，自然也没有重载，就是类和方法
 * 但是，模板里面的多态，是在编译期间就确定了具体要调用的代码，不需要在执行的时候去处理，性能会更好,这种又称为静态多态
 *
 * 传统多态，都是父类对象指向(引用)子类，调用子类里面重载的方法，是用虚函数来完成的，要用到虚函数表，
 * 并且是在执行的时候处理，所以性能没有静态多态好，这种又称为动态多态
 *
 *
 * */

int main() {

    //父类指针指向子类对象,
    Son1 son1;
    Father *fa1=&son1;
    Father *fa2=new Son2;
    fa1->say();
    fa2->say();

    //父类引用指向子类对象
    Son1 son11;
    Son2 son21;
    Father &fa11=son11;
    Father &fa21=son21;
    fa11.say();
    fa21.say();

    //模板函数中的多态
    Son3 son3;
    Son4 son4;
    func1(son3);
    func1(son4);


    return 0;
}

#include <iostream>
using namespace std;

template<class T1>
class Father {
public:
    void sonSay() {
        T1& son = static_cast<T1&>(*this); //把父类强转成子类对象
        son.say();
    }
};

class Son1 : public Father<Son1> {
public:
    void say() {
        cout << "son1" << endl;
    }
};


template<class T2>
class Son2 : public Father<Son2<T2>> {
public:
    void say() {
        cout << "son2" << endl;
    }
};


/*
 * 派生类当基类的类型参数
 *
 * 子类到父类，父类再调子类
 *
 * 只是一个技巧，如果遇到或者看到，要知道是什么意思
 *
 * */


int main() {

    Son1 son1;
    son1.sonSay();

    Son2<int> son2;
    son2.sonSay();

    return 0;
}

#include <iostream>
using namespace std;

class A {
public:
	A() {
		cout << "a" << endl;
	}
	int a;
};

class B {
public:
	B() {
		cout << "b" << endl;
	}
	int b;
};

class C : public A {

};

class D : public A, public B {

};

//把传过来的类变量当作父类来继承，这种称为混入
template<class ...T1>
class E : public T1...{

public:
	E() { cout << "e" << endl; }
};

template<class ...T2>
class F : public E<T2...> {

public:
	F() { cout << "f" << endl; }
};

using EA = E<A>;
using FEAB = F<A, B>;  //f->e->a,b


int main() {

	EA ea;
	ea.a = 123;
	cout << ea.a << endl;


	FEAB feab;
	feab.a = 123;
	feab.b = 456;
	cout << feab.a << "--" << feab.b << endl;


	E<A>e1;
	e1.a = 123;
	cout << e1.a << endl;

	E<A, B>e2;
	e2.a = 123;
	e2.b = 456;
	cout << e2.a << "--" << e2.b << endl;
	F<A>f1;
	f1.a = 123;
	cout << f1.a << endl;


	//传统继承
	C c1;
	c1.a = 123;
	cout << c1.a << endl;

	D d1;
	d1.a = 123;
	d1.b = 456;
	cout << d1.a << "--" << d1.b << endl;

	return 0;
}

a
e
123
a
b
e
f
123--456
a
e
123
a
b
e
123--456
a
e
f
123
a
123
a
b
123--456

#include <iostream>
using namespace std;


void func1() {

	int a;
	a = 123;

	int b = 456;

	//先去定义int 类型的变量(给变量分配了一个内存空间)，再赋值(把数据放到内存里面去)
	//先买房子，再去结婚(房子就是左值，媳妇儿就是右值)， 这样是不是能好理解一点


	//从字面上来说，左值就是放在赋值运算左边的，右值就是放在赋值运算右边的
	//a,b 是左值， 123,456 是右值




	a = a + 1;//a(这里用的是内存地址 左值)=a(这里用的是值123 还是左值，当成右值使用)+1   房子还是那个房子，只不过，房子里面又多了一个人，还住在那个房子里面
	b = b + 2;//同理 b(取内存地址 左值)=b(取值456 还是左值，当右值用)+2         生了双胞胎
	int c = a + b;//c(取内存地址 左值)=a(取值124 左值当右值用)+b(取值458 左值当右值用)


	//左值一般代表一个内存地址，右值一般用具体的数据
	//左值在某些场景下可以当右值来用，此时具有右值属性，但右值不能当左值来用
	//在分析一个表达式或变量是左值还是右值时，先看是不是左值，不是左值，就是右值

	int d = 123456;

	//123456=d;//



}

int main() {
	func1();

	return 0;
}

#include <iostream>
#include<string>
using namespace std;

/*
 *
 * 左值引用-绑定左值
 * const 左值引用，可以绑定左值和右值
 *
 * 右值引用-绑定右值-c++11引入
 * const 右值引用，只能绑定右值，不能绑定左值
 *
 * 引用类型的变量，在定义时就要初始化,且不能用NULL来赋值
 *
 * */


//左值引用-
void func1() {

    int a = 123;
    int& b = a;
    b = 456;
    cout << a << " " << b << endl;


    //int& c = 123;//左值引用不能绑定右值
    //string& d = string{ "abc" };//左值引用不能绑定临时对象，因为临时对象也是右值


    const int& e = a;
    //e = 789;

    const int& f = 123;   //const 左值引用可以绑定右值

    cout << f << endl;

    const string& g = string{ "abc" };
    cout << g << endl;

    //int& h = a + 1; //a(取123)+1  反回右值 无法用在左值引用绑定

    const int& i = a + 1;//


}

//右值引用
void func2() {

    int a = 123;

    //int&& b = a;//右值引用不能绑定左值

    int&& c = 123;
    c = 456;
    cout << c << endl;

    string&& d = string{ "abc" };//时对象也是右值
    d = "xyz";
    cout << d << endl;

    const int&& e = 123;
    //e = 456;

    const string&& f = string{ "abc" };

    //const int&& g = a;//const 右值引用不能绑定左值

    int&& h = a + 1;
    cout << h << endl;

    const int&& i = a + 1;


}


//引用的一些标准
void func3() {

    int a;
    a = 123;

    //int& b;
    //b = a;

    //int&& c;
    //c = 456;

    int* p = nullptr;
    //int& d = NULL;
    int&& e = NULL;
    cout << e << endl;

    //string&& f = NULL;
    //cout << f << "--" << endl;

}

int main() {
    func1();
    func2();
    func3();
    return 0;
}

#include <iostream>
#include<string>
using namespace std;


/*
 *
 * 返回左值引用的运算一般有 赋值=,取特定索引[],解引用&,前置自增自减运算++i 这些，我们可以将一个左值引用绑定到这些运算的返回值上
 *
 * 返回非引用类型的运算一般有  算术+-* /,关系,位,后置自增自减运算i++ 这些，返回的都是右值，可以用右值引用或 const 左值引用绑定
 *
 * 不管是左值引用还是右值引用，其本身也是左值，还是可以被左值引用绑定
 *
 * 所有的变量，都要看成是左值，都可以被左值引用来绑定（虽然有时候当作右值来使用）
 *
 * 函数里面的参数，都要看成左值
 *
 *
 * */

 //++i, i++
void func1() {

    int i = 123;

    //++i 左值-可以用左值引用绑定

    int& b = ++i;//先++ 再返回  i(取地址)=i(取值123)+1; int &b=i;

    printf("%d-%d--%p-%p\n", i, b, &i, &b);


    //左值可以被赋值
    (++i) = 456;

    printf("%d-%d--%p-%p\n", i, b, &i, &b);


    //i++ 右值-可以被右值引用接收
    int&& c = i++;//int tmp=i;i=i+1;int &&c=tmp;   tmp 临时变量 -- 临时变量是右值  且有新的内存地址
    printf("%d-%d--%p-%p\n", i, c, &i, &c);


}

void func2() {

    int a = 123;
    int& b = a;//左值引用 变量b本身也是左值
    int& c = b;//还是能被左值引用

    int&& e = 456;//右值引用 变量本身e 也是左值
    int& f = e; //还是能被左值引用

    //int&& g = b;

}

void func4(int a, int& b, int&& c) {

}


//左值转右值-c++11新引入
//std::move()  左值转右值，没有移动的意思
void func5() {
    int a = 123;
    int& b = a;


    //int&& c = a;
    int&& c = std::move(a);

    printf("%d-%d-%d---%p-%p-%p\n", a, b, c, &a, &b, &c);

    c = 456;
    printf("%d-%d-%d---%p-%p-%p\n", a, b, c, &a, &b, &c);

    int&& d = 789;
    //int&& e = d;
    int&& e = std::move(d);
    printf("%d-%d---%p-%p\n", d, e, &d, &e);
    e = 123;
    printf("%d-%d---%p-%p\n", d, e, &d, &e);

    int f = a;
    int g = std::move(a);
    printf("%d-%d-%d---%p-%p-%p\n", a, f, g, &a, &f, &g);


    string h = "abc";
    string i = h;
    string gg = std::move(h);//string g = std::move(string h) 之后  h里面的数据没有了 不是移走了
    //std::move 只是把左值转右值 但是加上 string g= 则是触发了string里面的移动构造，然后 h 里面的值被干掉了
    std::move(h);

    printf("%s-%s-%s===%p-%p-%p\n", h.c_str(), i.c_str(), gg.c_str(), &h, &i, &gg);


}


int main() {

    int x = 123;
    
    func1();
    func2();
    func4(x, x, 123);
    func5();

    return 0;
}

#include <iostream>
#include<string>
using namespace std;

/*
 *
 * 左值引用绑左值
 * 右值引用绑右值
 * std::move() 左值转右值
 *
 * const 左值引用可以绑右值
 * const 右值引用不能绑左值
 *
 * 万能引用(universal reference) 也称转发引用(forwarding reference)，未定义引用
 *
 *
 * 前提
 * 1 一定是在函数模板中
 * 2 一定发生了类型推导
 *
 *
 * 格式
 * template<class T>
 * func(T &&a){}    T1&&a    T1 &&a    T1&& a    T1 && a
 *
 *
 *
 *
 *
 * //这里是右值引用
 * template<class T>
 * func(vector<T> &&a){}
 *
 * //右值引用
 * func(int &&a){}
 *
 *
 *
 * 这种也是万能引用
 * auto &&x=123;
 * auto &&y=x;
 *
 *
 * */



 //左值引用
template<class T1>
void func1(T1& a) {
    cout << a << endl;
}

//右值引用 -- 实际上是万能引用 -- 能绑定左值，又能绑定右值
template<class T2>
void func2(T2&& a) {
    cout << a << endl;
    a = 456;
}

template<class T3>
class C1 {
public:
    //这里不是万能引用，这里是右值引用，因为在实例化C1的时候，必须显式指定T3,而不是自动推导出其数据类型
    void func1(T3&& a) {
        cout << a << endl;
    }

    //这种写法就是类成员函数的万能引用
    //这里是万能引用--因为此处是函数模板，并且发生了类型推导
    template<class T4>
    void func2(T4&& a) {
        cout << a << endl;
    }

};



//参数加const 修饰之后，由万能引用变回右值引用了
template<class T5>
void func3(const T5&& a) {
    cout << a << endl;

}

int main() {
    int a = 123;
    func1(a);


    func2(a);//万能引用-绑定左值
    func2(123);//万能引用绑定右值

    cout << a << endl;

    C1<int>c1;

    //c1.func1(a);//不去持
    c1.func1(123);//右值引用

    c1.func2(a);


    //func3(a);
    func3(123);

    auto&& x = 123;
    auto&& y = x;

    return 0;

}

#include <iostream>
#include<string>
using namespace std;


void func2(int& a, int&& b) {
    cout << a << "--" << b << endl;
}


//万能引用-能绑定左值引用，也能绑定右值引用
template<class T1, class T2>
void func1(T1&& a, T2&& b) {

    //转发-通过中间函数间接调用目标函数，如果目标函数有参数，则参数也要通过中间函数传递，此处的func2 相当于跳板函数,起到一个转发的作用
    //func2(a,b);

    //完美转发-在转发的过程中，实参属性完全保留，通过跳板函数完全传递给目标函数
    //在万能引用中--用 std::forward<>() 配合实现完美转发
    func2(
        std::forward<T1>(a),
        std::forward<T2>(b)
    );
}


void func3(int& a) {
    cout << "左值引用" << endl;
}
void func3(const int& a) {
    cout << "const 左值引用" << endl;
}
void func3(int&& a) {
    cout << "右值引用" << endl;
}

//void func3(const int &&a){
//    cout<<"const 右值引用"<<endl;
//}


template<class T3>
void func4(T3&& a) {
    func3(
        std::forward<T3>(a)
    );
}


int main() {

    int a = 1;
    func1(a, 123);

    int&& b = 123;//int &&b 是右值引用，没错,但是 变量b 本身是左值
    int& c = b;//所以此处，可以用左值引用绑定

    //int&& d = a;//左值不能用右值引用绑定


    int i = 1;
    const int j = 2;

    int& k = i;
    int&& l = 3;

    const int& m = i;
    const int&& n = 3;

    func4(i);//左值引用
    func4(123);//右值引用
    func4(std::move(i));//右值引用
    func4(int(123));//右值引用--临时对象
    func4(j);//const 左值引用

    func4(k);//左值引用
    func4(l);//左值引用
    func4(m);//const 左值引用
    func4(n);//const 左值引用


    return 0;
}

#include <iostream>
#include<string>
using namespace std;


int func2(int& a, int&& b) {
	cout << "func2--" << a << "--" << b << endl;
	return a + b;
}

string func3(int& a, int&& b, string c) {
	cout << "func3--" << a << "--" << b << "--" << c << endl;
	return c;
}

//可变参的函数模板的完美转发
template<class F, class ...T>
//auto func1(F f,T && ...a){
decltype(auto) func1(F f, T && ...a) {
	return f(
		std::forward<T>(a)...
	);
}


int main() {

	int a = 123;
	int rs1 = func1(func2, a, 123);//其实这里是函数指针
	string rs2 = func1(func3, a, 123, "abc");//其实这里是函数指针

	cout << endl << endl;
	cout << rs1 << "--" << rs2 << endl;


	return 0;
}

#include <iostream>
#include<string>
#include<vector>
using namespace std;

/*
 *
 * SFINAE(Substitution failure is not an error) - 替换失败不是错误
 *
 * 此处只针对函数(类)模板而言
 *
 * 当用一个具体的类型去替换函数模板中的类型参数时，在编译器器认为该类型无法匹配模板时，
 * 会略过此处，进而去寻找其它更适合的函数
 *
 * 如果没找到 会给出类似于 "note: candidate template ignored: substitution failure"(注意：已忽略候选模板：替换失败)
 * 的提示
 *
 * 继而报错 "error: no matching function for call to"
 *
 * */

template<class T>
typename T::size_type func1(T a) {
    return 123;
}

int func1(int a){
    return 456;
}


int main() {
    int a = 1;
    cout << func1(a) << endl;//是被发好人卡了，你很好，但我们不合适

    cout << func1(vector<int>{a}) << endl;

    //vector<int>::size_type ;

    return 0;
}

#include <iostream>
#include<string>
using namespace std;


template<class T>
struct S1 {
    //using type = T;
    typedef T type;
};


/*
 *
 * enable_if
 * 结构体(类)模板
 *
 * enable_if 中的条件特化可以看成一个条件分支语句，在编译期就能决定走哪个分支，条件是否成立
 *
 * 但是，代码中的条件分支语句，必须得执行的时候才知道条件是否成立，走哪个分支
 *
 *
 * 函数模板可以有条件分支
 *
 * 使用场景一般作为函数模板的返回值类型
 *
 * */


template<class T1>
//typename std::enable_if<(sizeof(T1) > 2),T1>::type func1(T1 a){
std::enable_if_t<(sizeof(T1) > 2), T1> func1(T1 a) {
    return a;
}



int main() {


    int a = func1(1);
    cout << a << endl;

    double b = 123;
    double c = func1(b);
    cout << c << endl;
    //func1<int>();
    //func1<char>();//给char 发好人卡了，我们不合适


    enable_if<true>::type* p1 = nullptr;   //void *p1=nullptr;
    enable_if<true, int>::type a1 = 123;       //int a=123;

    enable_if<(1 < 2)>::type* p2 = nullptr;    // void *p2=nullptr;



    S1<int>::type a111 = 123;    //int a=123;
    cout << a111 << endl;

    S1<string>::type b111 = "abc";//string b="abc";
    cout << b111 << endl;

    return 0;
}

#include <iostream>
#include<string>
using namespace std;

class C1 {

public:
    template<
        class T1,
        //class T2= typename enable_if< is_convertible<T1,string>::value >::type
        class T2 = std::enable_if_t<std::is_convertible<T1, string>::value>    //当 T1 为 string 的时候，给T2 赋值为void  T2 是个工具人，只要有值就行
    >
    C1(T1&& name) {
        this->name = std::forward<T1>(name);
        cout << "构造函数模板" << endl;
    }

    C1(const C1& c1) {
        this->name = c1.name;
        cout << "拷贝构造函数" << endl;
    }

    string name;
};


/*
 *
 * bool rs = std::is_convertible<T1,T2>::value
 * 判断T1类型 是否能隐式的转为T2类型，返回值是bool
 *
 * */

int main() {

    string name = "tom";



    C1 c1(name);//构造函数模板
    C1 c2(c1);//拷贝构造函数


    bool rs = std::is_convertible<double, int>::value;
    cout << (rs == true) << endl;


    return 0;
}

#include <iostream>
#include<string>

using namespace std;

/*
//泛化版
template <bool _Bp, class _If, class _Then>
struct conditional {
    typedef _If type;
};

//特化版
template <class _If, class _Then>
struct conditional<false, _If, _Then> {
    typedef _Then type;
};
*/

/*
 * std::conditional<bool,T1,T2>
 * 结构体模板
 *
 * 模板中编译期间条件预判断
 *
 *
 * 有点类似于三目运算
 *
 * */

int main() {

    conditional<true, int, char>::type t1;  //int
    conditional<false, int, char>::type t2; //char

    cout << typeid(t1).name() << endl;
    cout << typeid(t2).name() << endl;


    constexpr int a = 23;

    conditional<
        (a > 100),
        conditional<(a > 150), int, char>::type,
        conditional<(a > 50), bool, double>::type
            >::type t3;

    cout << typeid(t3).name() << endl;

    return 0;
}

#include <iostream>
#include<string>
#include<vector>
using namespace std;


/*
 * std::remove_all_extents<T>::type t1;
 *
 * c++11中开始引入
 * 获取数组元素的具体数据类型
 * 通过递归的方式实现
 *
 * */


template <class _Tp>
struct remove_all_extents_x {
    typedef _Tp type;
};

template <class _Tp>
struct remove_all_extents_x<_Tp[]> {
    typedef typename remove_all_extents_x<_Tp>::type type;
};

template <class _Tp, size_t _Np>
struct remove_all_extents_x<_Tp[_Np]> {
    typedef typename remove_all_extents_x<_Tp>::type type;
};

/*
 * remove_all_extents_x<int[2][3][4]>::type t1;
 *    typedef typename remove_all_extents_x<int[3][4]>::type type;
 *          typedef typename remove_all_extents_x<int[4]>::type type;
 *              typedef typename remove_all_extents_x<int>::type type;
 *
 * */

int main() {

    int a1[2][3][4]{};

    //remove_all_extents_x<decltype(a1)>::type t11;
    remove_all_extents_x<int[2][3][4]>::type t11;

    extern int b1[];//无边界数组


    cout << typeid(t11).name() << endl;


    int a[2]{};
    int b[2][3]{};
    int c[2][3][4]{};

    char d[2][3]{};
    int* e[2][3]{};
    vector<int>f[2]{};


    std::remove_all_extents<decltype(d)>::type t1;
    std::remove_all_extents<decltype(e)>::type t2;
    std::remove_all_extents<decltype(f)>::type t3;

    cout << typeid(t1).name() << endl;
    cout << typeid(t2).name() << endl;
    cout << typeid(t3).name() << endl;

    return 0;
}

#include <iostream>
#include<string>
using namespace std;

/*
 *
 * 萃取 - 并不是某一种具体的技术或某个具体类库或函数，更像一种编程思想，模式
 *
 * 萃取 - traits(特质)
 *
 * 萃取 - 主要用于对模板中的模板参数进行操作，这种模板我们一般称其为traits 模板，标准库中很常见
 *
 * 因为在标准库中都是这么写的，所以大家也要学习这种思想
 *
 *
 * 分类
 *
 * 固定萃取 - fixed traits   给定一个类型，萃取另一种类型，这两个类型之间的对应关系是固定的，所以称为固定萃取
 * 值萃取 - value traits     给定一个类型，得到一个值
 * 类型萃取 - type traits    从boots库中发展而来，实现了类型信息的提取和变换
 *
 *
 * */


int main(){

    return 0;
}

#include <iostream>
#include<string>
using namespace std;

template<class T1, class T2>
T1 func1(const T2* start, const T2* end) {
	cout << typeid(T1).name() << endl;
	cout << typeid(T2).name() << endl;
	T1 sum{};
	for (;;) {
		sum += (*start);
		if (start == end) {
			break;
		}
		start++;

	}
	return sum;
}






template<class T1>
struct sumType {};

template<>
struct sumType<char> {
	using type = int;
};

template<>
struct sumType<int> {
	using type = int64_t;
};

//........


template<class T1>
auto func2(const T1* start, const T1* end) {
	using sumT = typename sumType<T1>::type;
	sumT sum{};
	for (;;) {
		sum += (*start);
		if (start == end) {
			break;
		}
		start++;

	}
	return sum;
}




int main() {

	int a[] = { 1,2,3 };
	int b[] = { 1000000000,2000000000,2000000000 };
	char c[] = "abc";//97，98，99

	cout << func1<int>(&a[0], &a[2]) << endl;
	cout << func1<int64_t>(&b[0], &b[2]) << endl;
	cout << func1<int>(&c[0], &c[2]) << endl;


	cout << endl;
	cout << func2(&a[0], &a[2]) << endl;
	cout << func2(&b[0], &b[2]) << endl;
	cout << func2(&c[0], &c[2]) << endl;

	return 0;
}

int
int
6
__int64
int
5000000000
int
char
294

6
5000000000
294

#include <iostream>
#include<string>
#include<vector>
#include<list>
#include<array>
using namespace std;

template<class T1>
struct getType {
    using type = typename T1::value_type;
};

/*
template<class T1>
struct getType<vector<T1>>{
    using type = T1;
};

template<class T1>
struct getType<list<T1>>{
    using type = T1;
};
*/
template<class T1, size_t size>
struct getType<array<T1, size>> {
    using type = T1;
};

//别名
template<class T1>
using TYPE = typename getType<T1>::type;

template<class T1>
void func1(const T1& a) {
    cout << typeid(TYPE<T1>).name() << endl;
}

int main() {

    vector<int>a{};
    list<double>b{};
    array<char, 10>c{};

    func1(a);
    func1(b);
    func1(c);


    getType<decltype(a)>::type t1;
    getType<decltype(b)>::type t2;
    getType<decltype(c)>::type t3;


    TYPE<decltype(a)> t11;
    TYPE<decltype(b)> t21;
    TYPE<decltype(c)> t31;

    cout << typeid(t11).name() << endl;
    cout << typeid(t21).name() << endl;
    cout << typeid(t31).name() << endl;



    int a1[2]{};
    vector<int>b1{};
    remove_all_extents<decltype(a1)>::type t111;
    remove_all_extents<decltype(b1)>::type t211;
    cout << typeid(t111).name() << endl;
    cout << typeid(t211).name() << endl;

    return 0;
}

#include <iostream>
#include<string>
using namespace std;


/*
 *
 * 退化
 * std::decay<T1>;
 * 丢弃掉const修饰符，左右引用修饰符，数组转成指针，函数名转成函数指针，
 * 这种，称为类型退化
 *
 *
 * is_same<T1,T2>;
 * 判断T1，T2 是否是同一类型
 *
 *
 * 我们要自己用固定萃取的思路实现类似于 decay 的功能
 *
 *
 *
 * 去掉const
 * 去掉引用
 * 去掉数组的[]，转成指针
 * 将函数名转成函数指针
 *
 *
 * */


//去掉const 修饰符
template <class T1>
struct clearConst {
    using type = T1;
};

template <class T1>
struct clearConst<const T1> {
    using type = T1;
};


//去掉引用
template <class T1>
struct clearReference {
    using type = T1;
};

template <class T1>
struct clearReference<T1&> {
    using type = T1;
};

template <class T1>
struct clearReference<T1&&> {
    using type = T1;
};



int main() {

    int a = 123;
    const int b = 456;
    int& c = a;
    int&& d = 789;
    const int& e = b;


    //去掉const
    cout << is_same<clearConst<decltype(b)>::type, int>::value << endl;

    //去掉引用
    cout << is_same<clearReference<decltype(c)>::type, int>::value << endl;
    cout << is_same<clearReference<decltype(d)>::type, int>::value << endl;

    cout << endl;

    //组合--得先去掉引用，再去掉const
    cout << is_same<clearConst<clearReference<decltype(e)>::type>::type, int>::value << endl;

    cout<<is_same<clearReference<clearConst<decltype(e)>::type>::type ,int>::value<<endl;

    const int b1=456;

    std::decay<decltype(b1)>::type t1;

    //decay 去掉了const int 中的 const 修饰符
    cout<<is_same<decay<const int&&>::type ,int>::value<<endl;


    return 0;
}

#include <iostream>
#include<string>
using namespace std;


/*
 *
 * 退化
 * std::decay<T1>;
 * 丢弃掉const修饰符，左右引用修饰符，数组转成指针，函数名转成函数指针，
 * 这种，称为类型退化
 *
 *
 * is_same<T1,T2>;
 * 判断T1，T2 是否是同一类型
 *
 *
 * 我们要自己用固定萃取的思路实现类似于 decay 的功能
 *
 *
 *
 * 去掉const
 * 去掉引用
 * 去掉数组的[]，转成指针
 * 将函数名转成函数指针
 *
 *
 * 参数
 * 传统变量  const,引用 ------- 去掉
 * 数组    [int],[], const --- 转成指针
 * 函数    ------------------- 转成指针
 *
 *
 * */


 //去掉const 修饰符
template <class T1>
struct clearConst {
    using type = T1;
};

template <class T1>
struct clearConst<const T1> {
    using type = T1;
};


//去掉引用
template <class T1>
struct clearReference {
    using type = T1;
};

template <class T1>
struct clearReference<T1&> {
    using type = T1;
};

template <class T1>
struct clearReference<T1&&> {
    using type = T1;
};


template <class T1>
struct myDecay : clearReference<clearConst<T1>>::type {

};


//数组转指针
template <class T1, size_t size>
struct myDecay<T1[size]> {
    using type = T1*;
};

template <class T1>
struct myDecay<T1[]> {
    using type = T1*;
};

//函数转指针
template <class T1, class...args>
struct myDecay<T1(args...)> {
    using type = T1(*)(args...);
};



int func1(int a, char b) {
    cout << "func1--" << a << "---" << b << endl;
    return 0;
}

int main() {

    int a = 123;
    const int b = 456;
    int& c = a;
    int&& d = 789;
    const int&& e = 123;

    int f[4]{};
    const int g[5]{};

	cout << typeid(decltype(d)).name() << endl;
    cout << typeid(decay<decltype(d)>::type).name() << endl;
    cout << typeid(myDecay<decltype(d)>::type).name() << endl;

    cout << "----------------" << endl;

    cout << typeid(decltype(e)).name() << endl;
    cout << typeid(decay<decltype(e)>::type).name() << endl;
    cout << typeid(myDecay<decltype(e)>::type).name() << endl;

    cout << "----------------" << endl;
    cout << typeid(decltype(g)).name() << endl;
    cout << typeid(decay<decltype(g)>::type).name() << endl;
    cout << typeid(myDecay<decltype(g)>::type).name() << endl;
    cout << "----------------" << endl;


    cout << typeid(decltype(func1)).name() << endl;
    cout << typeid(decay<decltype(func1)>::type).name() << endl;
    cout << typeid(myDecay<decltype(func1)>::type).name() << endl;


    return 0;
}

int
int
int
----------------
int
int
int
----------------
int const [5]
int const * __ptr64
int const * __ptr64
----------------
int __cdecl(int,char)
int (__cdecl*)(int,char)
int (__cdecl*)(int,char)

#include <iostream>
#include<string>
using namespace std;

class C1 {
public:
	C1(int a, int b) {
		this->a = a;
		this->b = b;
	}
	int a;
	int b;

	C1& operator+=(const C1& c1) {
		this->a += c1.a;
		this->b += c1.b;
		return *this;
	}

};


template<class T1>
struct sumType {};

template<>
struct sumType<char> {
	using type = int;
	//static const type sum=0;
	static type initSum() {
		return 0;
	}
};

template<>
struct sumType<int> {
	using type = int64_t;
	//static const type sum=0;
	static type initSum() {
		return 0;
	}
};

template<>
struct sumType<C1> {
	using type = C1;
	//static const type sum=C1(0,0);
	static type initSum() {
		return C1(0, 0);
	}

};


template<class T1>
auto func2(const T1* start, const T1* end) {
	using sumT = typename sumType<T1>::type;
	sumT sum = sumType<T1>::initSum();
	//sumT sum{};
	for (;;) {
		sum += (*start);
		if (start == end) {
			break;
		}
		start++;

	}
	return sum;
}




int main() {

	int a[] = { 1,2,3 };
	int b[] = { 1000000000,2000000000,2000000000 };
	char c[] = "abc";//97，98，99
	C1 d[]{ C1(1,11),C1(2,22),C1(3,33) };


	cout << func2(&a[0], &a[2]) << endl;
	cout << func2(&b[0], &b[2]) << endl;
	cout << func2(&c[0], &c[2]) << endl;

	C1 rs = func2(&d[0], &d[2]);

	cout << rs.a << "--" << rs.b << endl;

	return 0;
}

#include <iostream>
#include<string>
using namespace std;

/*
 *
 * 类型萃取
 *
 * https://en.cppreference.com/w/cpp/types#Type_traits
 *
 * 自c++11开始，引入了很多萃取接口，我们把这些接口称为类型萃取接口，基本上都是用结构体(类)模板实现的
 *
 * 就是一堆接口，官方文档里面称为 type traits ，所以我们可以称这一些萃取接口为类型萃取
 *
 *
 * */


template<class T1, class T2>
struct myIsSame {
    using type = bool;
    static const type value = false;
};

template<class T1>
struct myIsSame<T1, T1> {
    using type = bool;
    static const type value = true;
};


int main() {

    int a = 123;
    int b = 456;
    double c = 7.89;

    const int e = 789;

    cout << is_same<decltype(a), decltype(b)>::value << endl;
    cout << is_same<decltype(a), decltype(c)>::value << endl;
    cout << endl;

    cout << myIsSame<decltype(a), decltype(b)>::value << endl;
    cout << myIsSame<decltype(a), decltype(c)>::value << endl;
    
    cout<<is_const<decltype(a)>::value<<endl;
    cout<<is_const<decltype(e)>::value<<endl;
    

    return 0;
}

#include <iostream>
#include<string>
using namespace std;

class C1 {
public:
    C1(int a, int b) {
        this->a = a;
        this->b = b;
    }
    int a;
    int b;

    C1& operator+=(const C1& c1) {
        this->a += c1.a;
        this->b += c1.b;
        return *this;
    }

    C1& operator-=(const C1& c1) {
        this->a -= c1.a;
        this->b -= c1.b;
        return *this;
    }

};


template<class T1>
struct sumType {};

template<>
struct sumType<char> {
    using type = int;
    static type initSum() {
        return 0;
    }
};

template<>
struct sumType<int> {
    using type = int64_t;
    static type initSum() {
        return 0;
    }
};

template<>
struct sumType<C1> {
    using type = C1;
    static type initSum() {
        return C1(0, 0);
    }
};

/*
 *
 * 策略 - 某种算法，或实现方式，或某种规则
 *
 * 策略萃取 - 给定一个类型，萃取出一种算法或实现方式
 *
 * 其实就是用模板的方式实现一些算法，再根据类型参数调用
 *
 *
 * 软件工程
 * 类似于乐高积木，
 *
 * */


struct myAdd {

    template<class T1, class T2>
    static void algorithm(T1& sum, const T2& val) {
        sum += val;
    }
};

struct mySub {
    template<class T1, class T2>
    static void algorithm(T1& sum, const T2& val) {
        sum -= val;
    }
};



template<class T1, class T2 = myAdd>
auto func2(const T1* start, const T1* end) {
    using sumT = typename sumType<T1>::type;
    sumT sum = sumType<T1>::initSum();

    for (;;) {
        T2::algorithm(sum, *start);

        if (start == end) {
            break;
        }
        start++;

    }
    return sum;
}



int main() {

    int a[] = { 1,2,3 };
    int b[] = { 1000000000,2000000000,2000000000 };
    char c[] = "abc";//97，98，99
    C1 d[]{ C1(1,11),C1(2,22),C1(3,33) };


    cout << func2<int, mySub>(&a[0], &a[2]) << endl;
    cout << func2(&b[0], &b[2]) << endl;
    cout << func2(&c[0], &c[2]) << endl;


    C1 rs = func2<C1, mySub>(&d[0], &d[2]);

    cout << rs.a << "===" << rs.b << endl;
    return 0;
}

#include <iostream>
#include<string>
using namespace std;

/*
 *
 * 元编程 - 模板元编程
 * 与萃取类似，是一种编程方式或思想，而不是某种具体的技术或方法，或某种具体的类库
 * 这种编程方式，能让代码在编译期间就执行并返回结果，以达到提升程序执行效率的作用
 *
 * 相当于执行前置
 *
 * 元函数
 * 用元编程的思想写的函数，可在编译期被执行的函数
 * 元函数包括模板
 *
 *
 * constexpr 关键子，在c++11中开始引入，标识变量或函数在编译期执行
 *
 *
 * objdump -DC a.out>bz.txt
 *
 * */


int func1(int a, int b) {
    return a + b;
}

constexpr int func2(int a, int b) {
    return a + b;
}

template<class T1>
constexpr T1 func3(T1 a, T1 b) {
    return a + b;
}

int main() {

    int a = func1(1111, 2222);
    //int b= func2(11111,22222);//不会编译期执行
    constexpr int b = func2(11111, 22222);//编译期执行

    constexpr int c = func3(111, 222);//编译期执行

    cout << a << "--" << b << endl;


    return 0;
}

#include <iostream>
#include<string>
using namespace std;

//这种 constexpr 递归的写法，要求编译器支持编译期递归

//阶乘 - n*(n-1) 5*4*3*2...

template<int a>
constexpr int func1() {
	return a * func1<a - 1>();
}

template<>
constexpr int func1<0>() {
	return 1;
}



//连续自然数求和 - 可变参函数模板  递归拆包
template<int ...a>
constexpr int func2 = 0;

template<int first, int ...a>
constexpr int func2<first, a...> = first + func2<a...>;




int main() {

	constexpr int a = func1<10>();
	cout << a << endl;

	constexpr int b = func2<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>;
	cout << b << endl;

	static_assert(b == 55, "b error");    //静态断言，编译器间进行判断


	return 0;
}