Eingehende Analyse von C++-Funktionsvorlagen und Klassenvorlagen

1. Funktionsvorlage

1. Vorlage

Name der Rückgabewerttypvorlage (formale Parameterliste) {

                                                                                                           ee3. Funktionsvorlagen können überladen werden, solange ihre formalen Parameterlisten oder Typparameterlisten vorhanden sind sind unterschiedlich

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

4. Funktionsvorlagen und die Reihenfolge der Funktionen
Wenn mehrere Funktionen und Funktionsvorlagen denselben Namen haben, verarbeitet der Compiler eine Funktionsaufrufanweisung wie folgt:

sucht zunächst nach einer gewöhnlichen Funktion (einer Funktion, die nicht aus einer Vorlage instanziiert wird), deren Parameter genau übereinstimmen.

Finden Sie eine Vorlagenfunktion mit genau passenden Parametern.

• Suchen Sie eine gewöhnliche Funktion, deren reale Parameter nach der automatischen Typkonvertierung angepasst werden können.

• Wenn keiner der oben genannten Punkte gefunden werden kann, wird ein Fehler gemeldet.

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

  Beim Abgleichen von Vorlagenfunktionen wird keine automatische Typkonvertierung durchgeführt

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

Klassenvorlage

• 1 🎜 > Fügen Sie beim Definieren einer Klasse einen oder mehrere Typparameter hinzu. Bei der Verwendung von Klassenvorlagen geben Sie an, wie Typparameter durch bestimmte Typen ersetzt werden sollen, und der Compiler generiert entsprechend entsprechende Vorlagenklassen.

Vorlage //Typparameterliste

Klasse Klassenvorlagenname {

Mitgliedsfunktion und Mitgliedsvariable

};

(1) So schreiben Sie Mitgliedsfunktionen in Klassenvorlagen:

Vorlage

Name der Rückgabewerttyp-Klassenvorlage :: Name der Mitgliedsfunktion (Parameterliste) {

             … Name der Klassenvorlage

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

2. Klassenvorlage zum Definieren von Objekten verwenden

Der Compiler ist der Prozess des Generierens einer Klasse aus einer Klassenvorlage, der als Instanziierung der Klassenvorlage bezeichnet wird. Eine aus einer Klassenvorlage instanziierte Klasse wird als Vorlagenklasse bezeichnet.

Zwei Vorlagenklassen derselben Klassenvorlage sind inkompatibel.

3. Funktionsvorlage als Klassenvorlagenmitglied

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;

4. Klassenvorlage und Nichttypparameter: Die „“ Vorlage kann Nicht-Typ-Parameter sein

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

• 5. Klassenvorlagen und Ableitung
  (1) Klassenvorlagen werden von Klassenvorlagen abgeleitet

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

• (2) Klassenvorlagen sind abgeleitet von Vorlagenklassen

  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属于不同的类

  (3) Klassenvorlagen werden von gewöhnlichen Klassen abgeleitet

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

(4) Gewöhnliche Klassen werden von Vorlagenklassen abgeleitet

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

6 Freundfunktionen

(1 ) Funktionen, Klassen und Mitgliedsfunktionen von Klassen dienen als Freunde von Klassenvorlagen

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

(2) Funktionsvorlagen dienen als Freunde von Klassenvorlagen

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

(3 ) Funktionsvorlagen dienen als Freunde von Klassen

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实例化来的类 ，都有以上三个友元

(4) Klassenvorlagen als Freunde von Klassenvorlagen

#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摸板类的友元

7. Klassenvorlagen und statische Mitgliedsvariablen

Statische Mitglieder können in der Klassenvorlage definiert werden, dann enthalten alle aus einer Klassenvorlage instanziierten Klassen dieselben statischen Mitglieder.

#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

Verwandte Empfehlungen:

Verwenden Sie C++, um das C++-Syntaxformat zu analysieren

c++11 – So definieren Sie einen Zeiger in C++ Intelligente Zeiger auf Funktionen?

Das obige ist der detaillierte Inhalt vonEingehende Analyse von C++-Funktionsvorlagen und Klassenvorlagen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!