c++ day3

1.模板
定义：template，告诉编译器，对于紧跟在后的函数模板，T代表一种类型，不要报错。
模板是一种类型推导，必须有参数才能推导。
template
T add(T a,T b)
{
cout<<“调用函数模板”<<endl;
return a+b;
}
int add(int a,int b)
{
cout<<“调用普通函数”<<endl;
return a+b;
}

int a=1,b=3;
char c=‘1’,d=‘2’;
cout<<add(a,c);//普通函数可以进行隐式类型转换，函数模板不可以
cout<<add(a,b);//如果出现了重载，优先使用普通函数
cout<<add<>(a,b)<<endl;//但是也可以通过强制调用模板，使用空参数列表
cout<<add(c,d)<<endl;//或者函数模板有更好的匹配，则使用函数模板

2.函数模板的局限性
不能对所有类型进行推导，如指针，数组，类等
template
bool cmp(T a,T b)
{
if(a==b)
return true;
else
return false;
}
class Student
{
public:
Student(int a)
{
this->age=a;

}
 int age;


void show()
{
cout<<" age is:"<<age<<endl;
}

};
int main(int argc,char **argv)
{
Student li(1);
Student cai(100);
cout<<cmp(li,cai)<<endl;//这里是识别不出来的，需要自己具体化自定义数据类型

return 0;

}
具体化自定义数据类型 template<> 返回值 函数名<类型>（参数也需要具体化）
template<> bool cmp(Student a,Student b)
{
if(a.age==b.age)
return true;
else
return false;
}

3.类模板
template<class nameType,class ageType>//注意这里的顺序要和构造函数的顺序一样，如果不是，编译器会告诉你找不到这个变量
class Student
{
public:
Student(nameType s,ageType a)
{
this->age=a;
this->name=s;
}
nameType name;
ageType age;
void show()
{
cout<<“name is:”<<name<<" age is:"<<age<<endl;
}

};
int main(int argc,char **argv)
{

Student<string,int> cai("cai",3);

//这里不能用自动类型推导，需要显式指定类型
string a=“cai”;
int b=3;
Student cai(a,b);
//上面这种表示就是错误的，编译器会找不到这两个变量
cai.show();

return 0;

}

4.类模板的继承
template<class ageType,class nameType>
class Base
{
public:
Base()=default;
Base(ageType a,nameType s)
{
age=a;
name=s;
}
ageType age;
nameType name;
};
template<class test1,class test2>
class Son:public Base<int,string>//类继承必须告诉T的类型，否则无法分配内存
{
public:
void show()
{
cout<<“age is:”<<age<<" and name is “<<name<<endl;
}
void teen(test1 a)
{
if(age>a)
cout<<name<<” is a teen"<<endl;
else
cout<<“no”<<endl;
}

}
Base<int,string> base(24,“caiwenlong”);//需要显式告诉编译器类型是什么
函数模板可以自动推导，但是类模板不可以
//在类外实现成员函数的时候，需要添加模板声明，同时最开始的时候定义的时候有几个变量就要有几个变量，就算没有用到。
template<class test1,class test2>
void Son<test1,test2>::teen(test1 a)
{
if(Son::age>a)
cout<<" is a teen"<<endl;
else
cout<<“no”<<endl;
}

6.类模板如果有参数，则在定义类对象时候需要指定参数的类型，类模板在做函数参数时候，需要制定类模板中的参数类型，总之一句话，因为类模板不能自动推导类型，所以需要自己显示定义。

7.异常
class Exc{
public:
};
void dowork()
{
throw Exc();
}
int main(int argc,char **argv)
{
try{
dowork();
}
catch(Exc&e)
{
cout<<“类的异常抛出”<<endl;
}
catch(…)
{

}
return 0;

}
try执行可能有异常存在的地方
throw抛出异常，
catch(类型)捕获异常，类型可以是自定义的
也可以指定抛出的类型，void dowork() throw(类型),如果没有处理这个类型则会崩溃。
栈解旋：try开始到throw抛出异常之前，所有栈上的对象都会被释放
如果想要用系统自带的异常，需要添加头文件stdexcept，exception是所有异常类的父类，可通过重写虚成员函数来实现自己的异常类

8.标准输入输出
cin,cout是类对象，系统已经定义好了的。
cin.get(一个参数) 一次读取一个字符
cin.getline(两个参数)读取字符串的时候，不会把换行符拿走