1. Introducción
La definición y el uso de la plantilla de clase y la plantilla de función son similares. A veces, hay dos o más clases cuyas funciones son las mismas, solo que los tipos de datos son diferentes.
- La plantilla de clase se utiliza para realizar la parametrización de tipo de los datos requeridos por la clase.
- Las plantillas de clases son particularmente importantes para representar estructuras de datos como matrices, tablas y gráficos. La representación y los algoritmos de estas estructuras de datos no se ven afectados por los tipos de datos incluidos.
2. Gramática
La redacción de la plantilla de clase en C ++ es la siguiente:
template <类型参数表>
class 类模板名{
成员函数和成员变量
};
La tabla de parámetros de tipo se escribe de la siguiente manera:
class类塑参数1, class类型参数2, ...
La sintaxis para escribir funciones miembro en una plantilla de clase fuera de la definición de plantilla de clase es la siguiente:
template <类型参数表>
返回值类型 类模板名<类型参数名列表>::成员函数名(参数表)
{
...
}
La forma de definir un objeto con una plantilla de clase es la siguiente:
类模板名<真实类型参数表> 对象名(构造函数实际参数表);
Si la plantilla de clase tiene un constructor sin parámetros, también puede usar la siguiente escritura:
类模板名 <真实类型参数表> 对象名;
Ejemplo:
template<class T>
class Person{
public:
Person(T id,T age){
this->mAge = age;
this->mId = id;
}
void Show(){
cout << "ID:" << mId << " Age:" << mAge << endl;
}
public:
T mId;
T mAge;
};
void main(){
//函数模板在调用的时候，可以自动类型推导
//类模板必须显式指定类型
Person<int> p(15,22);
p.Show();
}
En tercer lugar, la derivación de plantillas de clases.
- Plantilla de clase derivada de clase ordinaria
- Una plantilla de clase también se puede derivar de una plantilla de clase. En este caso, la tabla de parámetros de la plantilla de clase derivada debe contener los parámetros de la plantilla de clase base.
- La clase de plantilla tiene herencia múltiple como las clases ordinarias, es decir, se permite la herencia múltiple entre clases de plantilla.
Se pueden derivar nuevas clases de plantillas de clases, ya sea de plantillas de clases o de clases que no son de plantilla.
//类模板派生普通类
template<class T>
class Person{
public:
Person(){
mAge = 0;
}
public:
T mAge;
};
//类区定义对象，这个对象需要编译分配内存,要指定类型
class SubPerson : public Person<int>{
};
//类模板派生类模板
template<class T>
class Animal{
public:
void J(){
cout << mAge << "动物在叫!" << endl;
}
public:
T mAge;
};
template<class T>
class Cat : public Animal<T>{
};
int main(void)
{
Cat<int> cat;//指定类型
return 0;
}
Cuarto, la implementación de funciones miembro fuera de la plantilla de clase.
template<class T>
class Person{
public:
Person(T age, T id);
void Show();
private:
T mAge;
T mID;
};
//外部实现函数
template<class T>
Person<T>::Person(T age, T id){
this->mID = id;
this->mAge = age;
}
template<class T>
void Person<T>::Show(){
cout << "Age:" << mAge << " ID:" << mID << endl;
}
Cinco, compilación de plantillas de clase
En primer lugar, una unidad de compilación ( - Unidad Search.com ) se refiere a un .cpp * archivo y se #include todos .h archivos, .h código del archivo se ampliará para incluir su .cpp archivo, entonces el compilador .cpp archivo es una obj archivo (suponiendo que nuestra plataforma es Win32), este último tiene el PE * ( portable ejecutable , es decir, las ventanas archivo ejecutable) formato de archivo y contiene el código binario, pero puede no ser capaz de Ejecución, porque no hay Garantizar que debe haber una función principal . Una vez que el compilador compila todos los archivos * .cpp de un proyecto de forma separada, el vinculador los conecta para convertirse en un archivo .exe *.
Al igual que una clase, una plantilla de clase puede unir su implementación y declaración, o puede separar la interfaz de la implementación. Sin embargo, debido a razones históricas, el soporte del compilador para la compilación separada es muy débil y la fuerza del soporte varía según la plataforma.
Las plantillas de clase de STL están todas juntas con la interfaz y la implementación, y pueden seguir la corriente principal. (El archivo se guarda como *** class template.hpp ***, cuya esencia es mezclar el código de implementación de .cpp en el archivo de encabezado .h. La definición y la implementación están contenidas en el mismo archivo, y la persona que llama a esta clase solo necesita incluir el archivo hpp, no es necesario agregar cpp al proyecto para compilar).
Seis, la palabra clave estática en la plantilla de la clase.
Las variables miembro estáticas de la clase con diferentes parámetros de tipo son independientes entre sí, lo que está determinado por el mecanismo de implementación de la plantilla de clase.
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
template<class T>
class Person{
public:
static int a;
};
template<class T> int Person<T>::a = 0;//类外初始化
int main(void)
{
Person<int> p1, p2, p3;
Person<char> pp1, pp2, pp3;
p1.a = 10;
pp1.a = 100;
cout << p1.a << " " << p2.a << " " << p3.a << endl;//输出10 10 10
cout << pp1.a << " " << pp2.a << " " << pp3.a << endl;//输出100 100 100
return 0;
}
Se puede ver que los miembros estáticos de los objetos de plantilla de clase del mismo tipo, como int, son compartidos, y los miembros estáticos de los objetos de plantilla de clase de diferentes tipos como int, float y char no se comparten.