Plantilla de función C ++ (2)
Ayer resolví la plantilla de funciones de C ++ (1), y debes ceñirte a ella hoy. Hoy, continuaré organizando las notas de la plantilla de funciones de C ++. Hoy, principalmente organizaré la diferencia entre las funciones ordinarias y las plantillas de funciones, las reglas de llamada de las funciones ordinarias y las plantillas de funciones, y las limitaciones de las plantillas. ¡No digas tonterías, apúrate!
05 La diferencia entre la función ordinaria y la plantilla de función
1. La conversión de tipo automática (conversión de tipo implícita) puede ocurrir cuando se llama a una función ordinaria
2. La plantilla de función, la inferencia de tipo automática y la conversión de tipo implícita no pueden ocurrir.
3. Plantilla de función, use la pantalla para especificar el tipo, puede ocurrir una conversión de tipo implícita.
La implementación del código específico es la siguiente:
#include<iostream>
using namespace std;
//普通函数 减法
int Sub(int a,int b)
{
return(a-b);
}
//写一个模板函数
template<class T>
T Sub01(T a,T b)
{
return (a-b);
}
//写一个输出函数
void test01()
{
int a=100;
int b=200;
char c= 'c';
cout<<Sub(a,c)<<endl;
//自动类型推导输出
//cout<<Sub01(a,c)<<endl; 自动类型推导不可以发生隐式类型转换
//显示指定类型
cout<<Sub01<int>(a,c)<<endl;
}
int main()
{
test01();
system("pause");
return 0;
}
Nota: Se recomienda utilizar el método de mostrar el tipo especificado y llamar a la plantilla de función, porque usted mismo determina el tipo general T.
06 Reglas para llamar a funciones comunes y plantillas de funciones
1. Si se pueden implementar tanto las plantillas de funciones como las funciones comunes, llame primero a las funciones comunes.
2. Se puede forzar la llamada de la plantilla de función a través de la lista de parámetros de plantilla vacía.
3. Las plantillas de funciones también se pueden sobrecargar.
4. Si la plantilla de función puede producir una mejor coincidencia, llame primero a la plantilla de función.
#include<iostream>
using namespace std;
//1、如果函数模板和普通函数同时调用，则优先调用普通函数
//先来一个普通函数
void myfunc(int a,int b)
{
cout<<"This is ordinary func"<<endl;
}
//再来一个模板函数
template<typename T>
void myfunc(T a,T b)
{
cout<<"This is 模板函数"<<endl;
}
//再来一个函数重载
template<typename T>
void myfunc(T a,T b,T c)
{
cout<<"This is 重载模板函数"<<endl;
}
//写一个输出函数
void test01()
{
int a=10;
int b=20;
//myfunc(a,b);
//通过空模板参数列表来，强制调用函数模板
//myfunc<>(a,b);
//函数重载的调用
//myfunc<>(a,b,0);
//如果函数模板可以产生更好的匹配，优先调用函数模板
char c1='a';
char c2='b';
myfunc<>(c1,c2);//这是因为，输入的是字符，如果是调用普通函数需要进行隐式转换，即把字符转换为int数字，而调用模板的只用推导出T即可不用进行转换。
}**加粗样式**
//模板的话自动类型推导，不可以发生隐式类型转换。显示指定类型的话可以发生隐式转换。
int main()
{
test01();
system("pause");
return 0;
}
Nota: proporcione plantillas de funciones, no escriba funciones ordinarias para evitar ambigüedades.
07 Limitaciones de las
plantillas La versatilidad de las plantillas no es una panacea Algunos tipos de datos específicos requieren implementaciones especiales como las llamadas de tipos de datos bool y algunos tipos de datos personalizados como Person.
La prueba de caso de función es la siguiente:
#include<iostream>
using namespace std;
#include<string>
//函数的局限性，函数的通用性不是万能的
//有些特定的数据类型需要用具体话的方式来实现
//整一个自定义数据类型的对比
class Person
{
public:
Person(string name,int age)
{
this->m_name=name;
this->m_age=age;
}
//姓名
string m_name;
//年龄
int m_age;
};
//1、比较两个数据的大小
template<class T>
bool Contrast(T &a,T &b)
{
if(a==b)
{
return true;
}
else
{
return false;
}
}
//利用具体化Person的版本实现代码，具体化优先调用
template<> bool Contrast(Person &p1,Person &p2)
{
if(p1.m_name == p2.m_name && p1.m_age==p2.m_age)
{
return true;
}
else
{
return false;
}
}
//写一个测试输出函数
void test01()
{
int a=10;
int b=20;
bool ret=Contrast(a,b);
if(ret)
{
cout<<"a==b"<<endl;
}
else
{
cout<<"a!=b"<<endl;
}
}
//再写一个自定义类的输出函数
void test02()
{
Person p1("wjx",20);
Person p2("wjx",20);
bool ret=Contrast(p1,p2);
if(ret)
{
cout<<"p1==p2"<<endl;
}
else
{
cout<<"p1!=p2"<<endl;
}
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
Nota:
1. Cómo se define el carácter char c1 = 'a'; char c2 = 'b'.
2. Las clases como Persona \ Clase deben agregarse al final, si no, habrá errores inesperados.
3. El uso de plantillas específicas puede resolver la generalización de tipos personalizados.
4. Aprender plantillas no es escribir plantillas, sino utilizar las plantillas que proporciona el sistema en STL para satisfacer nuestras necesidades.