Modelos de classe C++

Neste tutorial, aprenderemos sobre modelos de classe em C++ com a ajuda de exemplos.

Os modelos são recursos poderosos de C++ que nos permite escrever programas genéricos. Existem duas maneiras de implementar modelos:

Modelos de função
Modelos de aula

Semelhante aos modelos de função, podemos usar modelos de classe para criar uma única classe para trabalhar com diferentes tipos de dados.

Os modelos de classe são úteis, pois podem tornar nosso código mais curto e mais gerenciável.

Declaração de modelo de classe

Um modelo de classe começa com a palavra-chave template seguido pelo(s) parâmetro(s) de template dentro de <> que é seguido pela declaração de classe.

template <class T>
class className {
  private:
    T var;
    ... .. ...
  public:
    T functionName(T arg);
    ... .. ...
};

Na declaração acima, T é o argumento de modelo que é um espaço reservado para o tipo de dados usado e class é uma palavra-chave.

Dentro do corpo da classe, uma variável de membro var e uma função de membro functionName() são ambos do tipo T .

Criando um objeto de modelo de classe

Depois de declarar e definir um modelo de classe, podemos criar seus objetos em outras classes ou funções (como o main() função) com a seguinte sintaxe

className<dataType> classObject;

Por exemplo,

className<int> classObject;
className<float> classObject;
className<string> classObject;

Exemplo 1:modelos de classe C++

// C++ program to demonstrate the use of class templates

#include <iostream>
using namespace std;

// Class template
template <class T>
class Number {
   private:
    // Variable of type T
    T num;

   public:
    Number(T n) : num(n) {}   // constructor

    T getNum() {
        return num;
    }
};

int main() {

    // create object with int type
    Number<int> numberInt(7);

    // create object with double type
    Number<double> numberDouble(7.7);

    cout << "int Number = " << numberInt.getNum() << endl;
    cout << "double Number = " << numberDouble.getNum() << endl;

    return 0;
}

Saída

int Number = 7
double Number = 7.7

Neste programa. criamos um modelo de classe Number com o código

template <class T>
class Number {
   private:
    T num;

   public:
    Number(T n) : num(n) {}
    T getNum() { return num; }
};

Observe que a variável num , o argumento construtor n , e a função getNum() são do tipo T , ou ter um tipo de retorno T . Isso significa que eles podem ser de qualquer tipo.

Em main() , implementamos o modelo de classe criando seus objetos

Number<int> numberInt(7);
Number<double> numberDouble(7.7);

Observe os códigos Number<int> e Number<double> no código acima.

Isso cria uma definição de classe para cada int e float , que são então usados em conformidade.

É obrigatório especificar o tipo ao declarar objetos de modelos de classe. Caso contrário, o compilador produzirá um erro.

//Error
Number numberInt(7);
Number numberDouble(7.7);

Definindo um membro de classe fora do modelo de classe

Suponha que precisamos definir uma função fora do modelo de classe. Podemos fazer isso com o seguinte código:

template <class T>
class ClassName {
    ... .. ...
    // Function prototype
    returnType functionName();
};

// Function definition
template <class T>
returnType ClassName<T>::functionName() {
    // code
}

Observe que o código template <class T> é repetido ao definir a função fora da classe. Isso é necessário e faz parte da sintaxe.

Se observarmos o código no Exemplo 1 , temos uma função getNum() que é definido dentro do modelo de classe Number .

Podemos definir getNum() fora de Number com o seguinte código:

template <class T>
class Number {
    ... .. ...
    // Function prototype
    T getnum();
};

// Function definition
template <class T>
T Number<T>::getNum() {
    return num;
}

Exemplo 2:calculadora simples usando modelos de classe

Este programa usa um modelo de classe para realizar adição, subtração, multiplicação e divisão de duas variáveis num1 e num2 .

As variáveis podem ser de qualquer tipo, embora tenhamos usado apenas int e float tipos neste exemplo.

#include <iostream>
using namespace std;

template <class T>
class Calculator {
   private:
    T num1, num2;

   public:
    Calculator(T n1, T n2) {
        num1 = n1;
        num2 = n2;
    }

    void displayResult() {
        cout << "Numbers: " << num1 << " and " << num2 << "." << endl;
        cout << num1 << " + " << num2 << " = " << add() << endl;
        cout << num1 << " - " << num2 << " = " << subtract() << endl;
        cout << num1 << " * " << num2 << " = " << multiply() << endl;
        cout << num1 << " / " << num2 << " = " << divide() << endl;
    }

    T add() { return num1 + num2; }
    T subtract() { return num1 - num2; }
    T multiply() { return num1 * num2; }
    T divide() { return num1 / num2; }
};

int main() {
    Calculator<int> intCalc(2, 1);
    Calculator<float> floatCalc(2.4, 1.2);

    cout << "Int results:" << endl;
    intCalc.displayResult();

    cout << endl
         << "Float results:" << endl;
    floatCalc.displayResult();

    return 0;
}

Saída

Int results:
Numbers: 2 and 1.
2 + 1 = 3
2 - 1 = 1
2 * 1 = 2
2 / 1 = 2

Float results:
Numbers: 2.4 and 1.2.
2.4 + 1.2 = 3.6
2.4 - 1.2 = 1.2
2.4 * 1.2 = 2.88
2.4 / 1.2 = 2

No programa acima, declaramos um modelo de classe Calculator .

A classe contém dois membros privados do tipo T :num1 &num2 , e um construtor para inicializar os membros.

Também temos add() , subtract() , multiply() e divide() funções que têm o tipo de retorno T . Também temos um void função displayResult() que imprime os resultados das outras funções.

Em main() , criamos dois objetos de Calculator :um para int tipo de dados e outro para float tipo de dados.

Calculator<int> intCalc(2, 1);
Calculator<float> floatCalc(2.4, 1.2);

Isso solicita que o compilador crie duas definições de classe para os respectivos tipos de dados durante a compilação.

Modelos de classe C++ com vários parâmetros

Em C++, podemos usar vários parâmetros de modelo e até usar argumentos padrão para esses parâmetros. Por exemplo,

template <class T, class U, class V = int>
class ClassName {
  private:
    T member1;
    U member2;
    V member3;
    ... .. ...
  public:
    ... .. ...
};

Exemplo 3:modelos C++ com vários parâmetros

#include <iostream>
using namespace std;

// Class template with multiple and default parameters
template <class T, class U, class V = char>
class ClassTemplate {
   private:
    T var1;
    U var2;
    V var3;

   public:
    ClassTemplate(T v1, U v2, V v3) : var1(v1), var2(v2), var3(v3) {}  // constructor

    void printVar() {
        cout << "var1 = " << var1 << endl;
        cout << "var2 = " << var2 << endl;
        cout << "var3 = " << var3 << endl;
    }
};

int main() {
    // create object with int, double and char types
    ClassTemplate<int, double> obj1(7, 7.7, 'c');
    cout << "obj1 values: " << endl;
    obj1.printVar();

    // create object with int, double and bool types
    ClassTemplate<double, char, bool> obj2(8.8, 'a', false);
    cout << "\nobj2 values: " << endl;
    obj2.printVar();

    return 0;
}

Saída

obj1 values: 
var1 = 7
var2 = 7.7
var3 = c

obj2 values: 
var1 = 8.8
var2 = a
var3 = 0

Neste programa, criamos um modelo de classe, chamado ClassTemplate , com três parâmetros, sendo um deles um parâmetro padrão.

template <class T, class U, class V = char>
class ClassTemplate {
  // code  
};

Observe o código class V = char . Isso significa que V é um parâmetro padrão cujo tipo padrão é char .

Dentro de ClassTemplate , declaramos 3 variáveis var1 , var2 e var3 , cada um correspondendo a um dos parâmetros do modelo.

class ClassTemplate {
   private:
    T var1;
    U var2;
    V var3;
    ... .. ...
    ... .. ...
};

Em main() , criamos dois objetos de ClassTemplate com o código

// create object with int, double and char types
ClassTemplate<int, double> obj1(7, 7.7, 'c');

// create object with double, char and bool types
ClassTemplate<double, char, bool> obj2(8, 8.8, false);

Aqui,

Objeto	T	U	V
`obj1`	`int`	`double`	`char`
`obj2`	`double`	`char`	`bool`

Para obj1 , T = int , U = double e V = char .

Para obj2 , T = double , U = char e V = bool .

Funções virtuais C++ C Palavras-chave e Identificadores

Linguagem C