C++-klassesjablonen

In deze zelfstudie leren we over klassjablonen in C++ met behulp van voorbeelden.

Sjablonen zijn krachtige functies van C++ waarmee we generieke programma's kunnen schrijven. Er zijn twee manieren waarop we sjablonen kunnen implementeren:

• Functiesjablonen
• Klassjablonen

Net als bij functiesjablonen kunnen we klassensjablonen gebruiken om een ​​enkele klasse te maken om met verschillende gegevenstypen te werken.

Klassjablonen zijn handig omdat ze onze code korter en beter beheersbaar kunnen maken.

Klassesjabloonverklaring

Een klassjabloon begint met het trefwoord template gevolgd door sjabloonparameter(s) binnen <> die wordt gevolgd door de klassenverklaring.

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

In de bovenstaande verklaring, T is het sjabloonargument dat een tijdelijke aanduiding is voor het gebruikte gegevenstype, en class is een trefwoord.

Binnen de hoofdtekst van de klasse, een lidvariabele var en een ledenfunctie functionName() zijn beide van het type T .

Een klassjabloonobject maken

Nadat we een klassensjabloon hebben gedeclareerd en gedefinieerd, kunnen we de objecten ervan maken in andere klassen of functies (zoals de main() functie) met de volgende syntaxis

className<dataType> classObject;

Bijvoorbeeld,

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

Voorbeeld 1:C++-klassesjablonen

// 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;
}

Uitvoer

int Number = 7
double Number = 7.7

In dit programma. we hebben een klassjabloon gemaakt Number met de code

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

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

Merk op dat de variabele num , het constructorargument n , en de functie getNum() zijn van het type T , of een retourtype T . hebben . Dat betekent dat ze van elk type kunnen zijn.

In main() , we hebben de klassensjabloon geïmplementeerd door de objecten ervan te maken

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

Let op de codes Number<int> en Number<double> in de bovenstaande code.

Dit creëert een klassedefinitie elk voor int en float , die vervolgens dienovereenkomstig worden gebruikt.

Het is verplicht om het type te specificeren bij het declareren van objecten van klassensjablonen. Anders zal de compiler een fout produceren.

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

Een klaslid definiëren buiten de klassjabloon

Stel dat we een functie buiten de klassensjabloon moeten definiëren. We kunnen dit doen met de volgende code:

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

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

Merk op dat de code template <class T> wordt herhaald terwijl de functie buiten de klasse wordt gedefinieerd. Dit is noodzakelijk en maakt deel uit van de syntaxis.

Als we kijken naar de code in Voorbeeld 1 , we hebben een functie getNum() dat is gedefinieerd in het klassensjabloon Number .

We kunnen getNum() define definiëren buiten Number met de volgende code:

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

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

Voorbeeld 2:Eenvoudige rekenmachine met klassjablonen

Dit programma gebruikt een klassensjabloon voor het optellen, aftrekken, vermenigvuldigen en delen van twee variabelen num1 en num2 .

De variabelen kunnen van elk type zijn, hoewel we alleen int . hebben gebruikt en float typen in dit voorbeeld.

#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;
}

Uitvoer

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

In het bovenstaande programma hebben we een klassensjabloon Calculator . gedeclareerd .

De klas bevat twee privéleden van het type T :num1 &num2 , en een constructor om de leden te initialiseren.

We hebben ook add() , subtract() , multiply() , en divide() functies met het retourtype T . We hebben ook een void functie displayResult() die de resultaten van de andere functies afdrukt.

In main() , we hebben twee objecten gemaakt van Calculator :één voor int gegevenstype en een ander voor float gegevenstype.

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

Dit vraagt ​​de compiler om twee klassedefinities te maken voor de respectieve datatypes tijdens het compileren.

C++-klassesjablonen met meerdere parameters

In C++ kunnen we meerdere sjabloonparameters gebruiken en zelfs standaardargumenten voor die parameters gebruiken. Bijvoorbeeld,

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

Voorbeeld 3:C++-sjablonen met meerdere parameters

#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;
}

Uitvoer

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

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

In dit programma hebben we een klassjabloon gemaakt, genaamd ClassTemplate , met drie parameters, waarvan één een standaardparameter is.

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

Let op de code class V = char . Dit betekent dat V is een standaardparameter waarvan het standaardtype char . is .

Binnen ClassTemplate , declareren we 3 variabelen var1 , var2 en var3 , die elk overeenkomen met een van de sjabloonparameters.

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

In main() , we maken twee objecten van ClassTemplate met de code

// 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);

Hier,

Voor obj1 , T = int , U = double en V = char .

Voor obj2 , T = double , U = char en V = bool .