Uma primeira olhada nos modelos C ++ - programação genérica, modelos de função e modelos de classe
Um, programação genérica
1.1 Por que usar programação genérica?
Para escrever uma função de troca geral, podemos usar a sobrecarga de função. Os detalhes específicos da sobrecarga de função podem ser encontrados no seguinte blog:
C ++ Elementary-Namespace, parâmetros padrão e sobrecarga de função
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
void Swap(double& left, double& right)
{
double temp = left;
left = right;
right = temp;
}
void Swap(char& left, char& right)
{
char temp = left;
left = right;
right = temp;
}
O uso de sobrecarga de função pode alcançar funções de troca gerais, mas existem dois problemas
- A sobrecarga da função é apenas o tipo é diferente , a taxa de reutilização do código é baixa, quando um novo tipo aparece, a função correspondente deve ser adicionada ;
- A capacidade de manutenção do código é baixa e um erro faz com que todas as sobrecargas dêem errado.
Portanto, as pessoas pensam em uma maneira de dizer ao compilador um modelo, deixar que o compilador use o modelo para gerar código de acordo com diferentes tipos , o que leva à programação genérica .
2.2 O que é programação genérica?
Escrever código genérico que não tem nada a ver com tipos é um meio de reutilização de código. Os modelos são a base da programação genérica .
Dois, modelo de função
2.1 O que é um template de função?
O template de função representa uma família de funções. O template de função não tem nada a ver com o tipo. Ele é parametrizado quando usado, e uma versão de tipo específico da função é gerada de acordo com o tipo do parâmetro atual .
2.2 Como usar o template de função?
<1> Formato do modelo de função
template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表){}
Aqui está uma castanha:
//2.2
template<typename T>
void Swap(T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
Nota
typename é usado para definir palavras-chave de parâmetro de modelo , e você também pode usar classe (lembre-se: você não pode usar struct em vez de classe)
2.3 Princípio do Template de Função
O gabarito de função é um projeto, que em si não é uma função , um compilador do molde para produzir um uso específico de tipos específicos de funções . Então, na verdade, o modelo deve entregar as coisas repetitivas que deveríamos ter feito para o compilador.
No estágio de compilação do compilador, para o uso de funções de modelo, o compilador precisa deduzir e gerar os tipos correspondentes de funções para invocação com base em os tipos de argumentos transmitidos .. Por exemplo, ao usar um modelo de função com o tipo duplo, o compilador determina T como o tipo duplo deduzindo o tipo do parâmetro real e, em seguida, gera um código que lida com o tipo duplo, e o mesmo é verdadeiro para o caractere modelo.
<1> Instanciação do modelo de função
Quando um template de função é usado com diferentes tipos de parâmetros , ele é chamado de instanciação do template de função . A instanciação do parâmetro do modelo é dividida em: instanciação implícita e instanciação explícita .
- Instanciação implícita: deixe o compilador deduzir o tipo real do parâmetro do modelo com base no parâmetro real
- Instanciação explícita: especifique o tipo real do parâmetro do modelo com <> após o nome da função.
Se o tipo não corresponder, o compilador tentará realizar uma conversão implícita de tipo. Se a conversão falhar, o compilador relatará um erro.
<2> O princípio de correspondência dos parâmetros do modelo
- Uma função não modelo pode existir ao mesmo tempo que um modelo de função com o mesmo nome, e o modelo de função também pode ser instanciado como a função não modelo .
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非模板函数匹配，编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
}
int main()
{
Test();
return 0;
}
2. Para uma função não modelo e um modelo de função com o mesmo nome, se outras condições forem iguais, a função não modelo será chamada primeiro durante a transferência e uma instância não será gerada a partir do modelo. Se o modelo puder produzir uma função com uma correspondência melhor, o modelo será selecionado .
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}
3. As funções de modelo não permitem a conversão automática de tipo, mas as funções comuns podem realizar a conversão automática de tipo
Três, modelo de classe
3.1 Definição do formato do modelo de classe
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};
O uso de modelos de classe visa resolver o problema de armazenamento de diferentes tipos de dados na classe , por exemplo:
// 动态顺序表
// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
{
public:
Vector(size_t capacity = 10)
: _pData(new T[capacity])
, _size(0)
, _capacity(capacity)
{
}
// 析构函数
~Vector()
{
if(_pData)
delete[] _pData;
_size = _capacity = 0;
}
void PushBack(const T& data)；
void PopBack()；
// ...
size_t Size() {
return _size; }
T& operator[](size_t pos)
{
assert(pos < _size);
return _pData[pos];
}
private:
T* _pData;
size_t _size;
size_t _capacity;
};
Deve-se notar aqui que se declararmos a função na classe a ser definida fora da classe, precisamos adicionar a lista de parâmetros do modelo, como o destruidor
3.2 Instanciação de um modelo de classe
Como usar o modelo de classe acima?
A instanciação do modelo de classe é diferente da instanciação do modelo de função. A instanciação do modelo de classe precisa estar emNome do modelo de classe seguido por <>,entãoColoque o tipo instanciado em <>Ou seja, o nome do modelo de classe não é a classe real, mas o resultado da instanciação é a classe real.
int main()
{
Vector<int> s1;
Vector<double> s2;
Vector<char> s3;
return 0;
}
