Analyse approfondie des modèles de fonctions et des modèles de classe C++

1. Modèle de fonction

1. Définition

modèle f1aab389decb776c77b62e9e070c22c8
Nom du modèle de type de valeur de retour (liste formelle des paramètres) {
                                                                    🎜>
<.>3. Les modèles de fonctions peuvent être surchargés, à condition que leurs listes de paramètres formels ou leurs listes de paramètres de type le soient. différent

template <class T1, class T2>
T2 print(T1 arg1, T2 arg2)
{
    cout<< arg1 << " "<< arg2<<endl;
    return arg2;
}

4. L'ordre des modèles de fonction et des fonctions

Lorsqu'il existe plusieurs fonctions portant le même nom que le modèle de fonction, le compilateur traite une instruction d'appel de fonction comme suit :

#include <iostream>
using namespace std;
template <class T>
T Inc(T n){
    return 1 + n;
}
int main(){
    cout << Inc<double>(4)/2; //输出 2.5
    return 0;
}

template<class T1, class T2>
void print(T1 arg1, T2 arg2) {
    cout<< arg1 << " "<< arg2<<endl;
}
template<class T>
void print(T arg1, T arg2) {
    cout<< arg1 << " "<< arg2<<endl;
}
template<class T,class T2>
void print(T arg1, T arg2) {
    cout<< arg1 << " "<< arg2<<endl;
}

Trouvez d'abord une fonction ordinaire avec des paramètres exactement correspondants (non instanciés par le modèle).

Trouvez une fonction de modèle avec des paramètres exactement correspondants.

• Trouvez une fonction ordinaire dont les paramètres réels peuvent correspondre après une conversion de type automatique.

• Si aucun des éléments ci-dessus ne peut être trouvé, une erreur sera signalée.
5. Lors de la correspondance des fonctions du modèle, la conversion de type automatique n'est pas effectuée

• Modèle de classe

1.

template <class T>
T Max( T a, T b) {
    cout << "TemplateMax" <<endl; return 0;
}
template <class T,class T2>
T Max( T a, T2 b) {
    cout << "TemplateMax2" <<endl; return 0;
}
double Max(double a, double b){
    cout << "MyMax" << endl; return 0;
}
int main() {
    Max( 1.2,3.4);     // 输出MyMax
    Max(4, 5);         //输出TemplateMax
    Max( 1.2, 3);      //输出TemplateMax2
    return 0;
}

Lors de la définition d'une classe, ajoutez un ou plusieurs paramètres de type. Lorsque vous utilisez des modèles de classe, vous spécifiez comment les paramètres de type doivent être remplacés par des types spécifiques, et le compilateur génère les classes de modèles correspondantes en conséquence.

template<class T>
T myFunction( T arg1, T arg2)
{ cout<<arg1<<" "<<arg2<<"\n"; return arg1;}
……
myFunction( 5, 7);      //ok ：replace T with int
myFunction( 5.8, 8.4);  //ok： ： replace T with double
myFunction( 5, 8.4);    //error ，no matching function for callto &#39;myFunction(int, double)&#39;

modèle d3b503ce35e4d4a1ca7c41df2e579e29 // liste de paramètres de type

nom du modèle de classe {

fonction membre et variable membre

};

(1) Comment écrire des fonctions membres dans des modèles de classe : modèle d3b503ce35e4d4a1ca7c41df2e579e29
Nom du modèle de classe de type de valeur de retour 3f5896ad40ea994f7b4221a2011f46b9:: Nom de la fonction membre (liste des paramètres)                                                                                                                                                                                                   Nom du modèle de classe e1e8d98f0bd3f359bc2ba1491a9ceb3c

2. Utiliser un modèle de classe pour définir des objets

Compile Le processus de génération d'une classe à partir d'un modèle de classe est appelé instanciation du modèle de classe. Une classe instanciée à partir d’un modèle de classe est appelée classe modèle.



Deux classes modèles du même modèle de classe sont incompatibles.

// Pair类模板
template <class T1,class T2>
class Pair{
public:
    T1 key; //关键字
    T2 value; //值
    Pair(T1 k,T2 v):key(k),value(v) { };
    bool operator < ( const Pair<T1,T2> & p) const;
};
template<class T1,class T2>
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{  //Pair的成员函数 operator <
    return key < p.key;
}
int main(){
    Pair<string,int> student("Tom",19);   //实例化出一个类 Pair<string,int>
    cout << student.key << " " << student.value;
    return 0;
}
//输出：
Tom 19

3. Modèle de fonction en tant que membre du modèle de classe

• 4. Modèle de classe et paramètres non-type : "bd36a0c56bb724e4428d77485bb4e310" template Les paramètres non-type peuvent apparaître dans

• 5. Modèles de classe et dérivation
  (1) Les modèles de classe sont dérivés des modèles de classe

(2 ) Modèles de classe Dérivés de la classe modèle

template <class T>
class A{
    public:
        template<class T2>
        void Func( T2 t) { cout << t; } //成员函数模板
};

(3) Modèle de classe dérivé de la classe ordinaire

template <class T, int size>
class CArray{
    T array[size];
public:
    void Print(){
        for( int i = 0;i < size; ++i)
        cout << array[i] << endl;
    }
};
CArray<double,40> a2;
CArray<int,50> a3;     //a2和a3属于不同的类

(4) Classe ordinaire dérivée de la classe modèle

6, Modèles de classe et fonctions amies

template <class T1,class T2>              int main() {
class A {                                        B<int,double> obj1;
    T1 v1; T2 v2;                                C<int> obj2;
};                                               return 0;
template <class T1,class T2>              }
class B:public A<T2,T1> {                 class B<int,double>:
    T1 v3; T2 v4;                             public A<double,int>{
};                                            int v3; double v4;
template <class T>                        };
class C:public B<T,T> {
    T v5;
};

(1) Les fonctions, les classes et les fonctions membres des classes servent d'amis aux modèles de classe

template <class T1,class T2>
class A {
    T1 v1; T2 v2;
};
template <class T>
class B:public A<int,double> {
    T v;
};
int main() {
    B<char> obj1;     //自动生成两个模板类 ：A<int,double> 和 B<char>
    return 0;
}

(2) Les modèles de fonctions servent d'amis aux modèles de classe

class A {
    int v1;
};
template <class T>
    class B:public A { //所有从B实例化得到的类 ，都以A为基类
    T v;
};
int main() {
    B<char> obj1;
    return 0;
}

(3) Modèle de fonction en tant qu'ami de la classe

template <class T>
class A {
    T v1;
    int n;
};
class B:public A<int> {
    double v;
};
int main() {
    B obj1;
    return 0;
}

(4) Modèle de classe en tant qu'ami du modèle de classe

7. Modèle de classe et variables membres statiques

void Func1() { }
class A { };
class B{
    public:
        void Func() { }
};
template <class T>
class Tmpl{
    friend void Func1();
    friend class A;
    friend void B::Func();
}; //任何从Tmp1实例化来的类 ，都有以上三个友元

Les membres statiques peuvent être définis dans un modèle de classe, puis toutes les classes instanciées à partir de ce modèle de classe contiendront les mêmes membres statiques.

#include <iostream>
#include <string>
using namespace std;
template <class T1,class T2>
class Pair{
    private:
        T1 key; //关键字
        T2 value; //值
    public:
        Pair(T1 k,T2 v):key(k),value(v) { };
        bool operator < ( const Pair<T1,T2> & p) const;
        template <class T3,class T4>
        friend ostream & operator<< ( ostream & o,const Pair<T3,T4> & p);
};
template <class T1,class T2>
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const{ //"小"的意思就是关键字小
    return key < p.key;
}
template <class T1,class T2>
ostream & operator<< (ostream & o,const Pair<T1,T2> & p){
    o << "(" << p.key << "," << p.value << ")" ;
    return o;
}
int main()
{
    Pair<string,int> student("Tom",29);
    Pair<int,double> obj(12,3.14);
    cout << student << " " << obj;
    return 0;
}
//输出：
(Tom,29) (12,3.14)
任意从 template <class T1,class T2>
       ostream & operator<< (ostream & o,const Pair<T1,T2> & p)
生成的函数，都是任意Pair摸板类的友元

Recommandations associées :

#include <iostream>
using namespace std;
class A
{
    int v;
public:
    A(int n):v(n) { }
    template <class T>
    friend void Print(const T & p);
};
template <class T>
void Print(const T & p){
    cout << p.v;
}
int main() {
    A a(4);
    Print(a);
    return 0;
}
//输出：4

Utiliser C++ pour analyser le format de syntaxe C++

template <class T>
class B {
    T v;
public:
    B(T n):v(n) { }
    template <class T2>
    friend class A;
};
template <class T>
class A {
    public:
    void Func( )  {
        B<int> o(10);
        cout << o.v << endl;
    }
};

c++11 - Comment définir en C++ Un pointeur intelligent vers une fonction ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!