C++의 함수 템플릿과 클래스 템플릿에 대한 심층 분석

1. 함수 템플릿

1. 정의

템플릿 < 클래스 유형 매개변수 1, 클래스 유형 매개변수 2,...>
반환값 유형 템플릿 이름(형식 매개변수 목록){
함수 본문
};

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

2. 매개변수 없이 함수 템플릿 인스턴스화

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

3. 공식 매개변수 목록이나 유형 매개변수 목록이 다른 한 함수 템플릿이 오버로드될 수 있습니다.

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

#🎜 🎜# 4. 함수 템플릿과 함수의 순서

동일한 이름의 함수와 함수 템플릿이 여러 개 있을 때 컴파일러는 함수 호출문을 다음과 같이 처리합니다

#🎜 🎜 #

먼저 매개변수가 정확히 일치하는 일반 함수(템플릿에서 인스턴스화되지 않은 함수)를 찾습니다.
매개변수가 정확히 일치하는 템플릿 함수를 찾습니다.
자동 유형 변환 후 실제 매개변수와 일치할 수 있는 일반 함수를 찾습니다.
위 항목 중 아무것도 찾을 수 없으면 오류가 보고됩니다.

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

5. 템플릿 기능 일치 시 자동 유형 변환이 수행되지 않습니다

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;

2. 클래스 템플릿

#🎜🎜 # 1. 정의

클래스를 정의할 때 하나 이상의 유형 매개변수를 추가합니다. 클래스 템플릿을 사용할 때 유형 매개변수를 특정 유형으로 대체하는 방법을 지정하면 컴파일러는 이에 따라 해당 템플릿 클래스를 생성합니다.

템플릿 <클래스 유형 매개변수 1, 클래스 유형 매개변수 2,...> //유형 매개변수 목록

클래스 클래스 템플릿 이름{

멤버 함수 및 멤버 변수 };


(1) 클래스 템플릿에서 멤버 함수를 작성하는 방법: 템플릿 <클래스 유형 매개변수 1, 클래스 유형 매개변수 2, ... > //유형 매개변수 목록

반환값 유형 클래스 템플릿 이름<유형 매개변수 이름 목록>::멤버 함수 이름(매개변수 목록){

(2) 클래스 템플릿을 사용하여 정의하는 방법 객체:
클래스 템플릿 이름<실제 유형 매개변수 목록> 객체 이름(생성자 실제 매개변수 목록);

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

2. 클래스 템플릿 사용 객체 정의

#🎜 🎜#
컴파일러가 클래스 템플릿에서 클래스를 생성하는 프로세스를 클래스 템플릿의 인스턴스화라고 합니다. 클래스 템플릿에서 인스턴스화된 클래스를 템플릿 클래스라고 합니다.

동일한 클래스 템플릿의 두 템플릿 클래스가 호환되지 않습니다.
3. 클래스 템플릿 멤버로서의 함수 템플릿

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

  4. 클래스 템플릿 및 비유형 매개변수: "< 클래스 템플릿 비유형 매개변수가 테이블에 나타날 수 있습니다>"

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

5. 클래스 템플릿 및 파생

(1) 클래스 템플릿은 클래스 템플릿에서 파생됩니다

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

#🎜🎜 #(2) 클래스 템플릿은 템플릿 클래스에서 파생됨

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

(3) 클래스 템플릿은 일반 클래스에서 파생됨

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

(4) 일반 클래스가 파생됨 템플릿 클래스에서

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

6. 클래스 템플릿 및 친구 함수

(1) 클래스의 함수, 클래스 및 멤버 함수는 클래스 템플릿의 친구 역할을 합니다

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

(2) 클래스의 친구 역할을 하는 함수 템플릿 Friend of template

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

(3) 클래스의 친구 역할을 하는 함수 템플릿

#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

(4) 클래스의 친구 역할을 하는 클래스 템플릿#🎜 🎜#

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

#🎜 🎜#7. 클래스 템플릿 및 정적 멤버 변수

정적 멤버는 클래스 템플릿에 정의될 수 있으며, 클래스 템플릿에서 인스턴스화된 모든 클래스에는 동일한 정적 멤버가 포함됩니다.

#include <iostream>
using namespace std;
template <class T>
class A{
    private:
        static int count;
    public:
        A() { count ++; }
        ~A() { count -- ; };
        A( A & ) { count ++ ; }
        static void PrintCount() { cout << count << endl; }
};
template<> int A<int>::count = 0;
template<> int A<double>::count = 0;
int main(){
    A<int> ia;
    A<double> da;
    ia.PrintCount();
    da.PrintCount();
    return 0;
}
//输出：1  1

관련 권장 사항:

C++를 사용하여 C++ 구문 형식 분석

c+ +11 - C++에서 함수에 대한 스마트 포인터를 정의하는 방법은 무엇입니까?

위 내용은 C++의 함수 템플릿과 클래스 템플릿에 대한 심층 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!