[c++] 전달 선언은 언제 사용할 수 있습니까?

지금까지 답변은 클래스 템플릿의 전달 선언을 사용할 수있는 시점을 설명하지 않습니다. 그래서, 여기에 간다.

클래스 템플릿은 다음과 같이 선언하여 전달할 수 있습니다.

template <typename> struct X;

의 구조에 따라 허용 대답 ,

할 수있는 것과 할 수없는 것이 있습니다.

불완전한 유형으로 할 수있는 작업 :

• 다른 클래스 템플릿에서 멤버를 불완전한 형식에 대한 포인터 또는 참조로 선언합니다.

  template <typename T>
  class Foo {
      X<T>* ptr;
      X<T>& ref;
  };

• 불완전한 인스턴스화 중 하나에 대한 포인터 또는 참조가되도록 멤버를 선언하십시오.

  class Foo {
      X<int>* ptr;
      X<int>& ref;
  };

• 불완전한 유형을 수락하거나 반환하는 함수 템플릿 또는 멤버 함수 템플릿을 선언합니다.

  template <typename T>
     void      f1(X<T>);
  template <typename T>
     X<T>    f2();

• 불완전한 인스턴스화 중 하나를 수락 / 반환하는 함수 또는 멤버 함수를 선언하십시오.

  void      f1(X<int>);
  X<int>    f2();

• 불완전한 유형에 대한 포인터 / 참조를 수락 / 반환하는 함수 템플리트 또는 멤버 함수 템플리트를 정의하십시오 (하지만 멤버를 사용하지 않음).

  template <typename T>
     void      f3(X<T>*, X<T>&) {}
  template <typename T>
     X<T>&   f4(X<T>& in) { return in; }
  template <typename T>
     X<T>*   f5(X<T>* in) { return in; }

• 불완전한 인스턴스화 중 하나에 대한 포인터 / 참조를 수락 / 반환하는 함수 또는 메소드를 정의하십시오 (그러나 멤버를 사용하지 않음).

  void      f3(X<int>*, X<int>&) {}
  X<int>&   f4(X<int>& in) { return in; }
  X<int>*   f5(X<int>* in) { return in; }

• 다른 템플릿 클래스의 기본 클래스로 사용

  template <typename T>
  class Foo : X<T> {} // OK as long as X is defined before
                      // Foo is instantiated.
  
  Foo<int> a1; // Compiler error.
  
  template <typename T> struct X {};
  Foo<int> a2; // OK since X is now defined.

• 이를 사용하여 다른 클래스 템플릿의 멤버를 선언하십시오.

  template <typename T>
  class Foo {
      X<T> m; // OK as long as X is defined before
              // Foo is instantiated. 
  };
  
  Foo<int> a1; // Compiler error.
  
  template <typename T> struct X {};
  Foo<int> a2; // OK since X is now defined.

• 이 유형을 사용하여 함수 템플릿 또는 메소드 정의

  template <typename T>
    void    f1(X<T> x) {}    // OK if X is defined before calling f1
  template <typename T>
    X<T>    f2(){return X<T>(); }  // OK if X is defined before calling f2
  
  void test1()
  {
     f1(X<int>());  // Compiler error
     f2<int>();     // Compiler error
  }
  
  template <typename T> struct X {};
  
  void test2()
  {
     f1(X<int>());  // OK since X is defined now
     f2<int>();     // OK since X is defined now
  }

불완전한 유형으로는 할 수없는 일 :

• 인스턴스화 중 하나를 기본 클래스로 사용

  class Foo : X<int> {} // compiler error!

• 인스턴스화 중 하나를 사용하여 멤버를 선언하십시오.

  class Foo {
      X<int> m; // compiler error!
  };

• 인스턴스화 중 하나를 사용하여 함수 또는 메소드 정의

  void      f1(X<int> x) {}            // compiler error!
  X<int>    f2() {return X<int>(); }   // compiler error!

• 불완전한 유형의 변수를 역 참조하려는 경우 인스턴스화 중 하나의 메소드 또는 필드를 사용하십시오.

  class Foo {
      X<int>* m;
      void method()
      {
          m->someMethod();      // compiler error!
          int i = m->someField; // compiler error!
      }
  };

• 클래스 템플릿의 명시 적 인스턴스 생성

  template struct X<int>;

답변

class X;  // forward for two legal declarations 
X returnsX();
void XAcceptor(X);

XAcepptor( returnsX() );  // X declaration needs to be known here