Ne zaman bir ileri bildirim kullanabilirim?

Başka bir sınıfın başlık dosyasındaki bir sınıfın ileri bildirimi yapmak için izin verildiğinde tanımını arıyorum:

Bir temel sınıf için, üye olarak tutulan bir sınıf için, üye işlevine başvuru yoluyla geçirilen bir sınıf için vb. Yapmama izin veriliyor mu?

Kendinizi derleyicinin konumuna koyun: bir tür bildirdiğinizde, tüm derleyici bu türün var olduğunu bilir; boyutu, üyeleri veya yöntemleri hakkında hiçbir şey bilmiyor. Bu yüzden eksik tip denir . Bu nedenle, bir üye veya temel sınıf bildirmek için türü kullanamazsınız, çünkü derleyicinin tür düzenini bilmesi gerekir.

Aşağıdaki ileriye dönük beyanı varsayarsak.

class X;

İşte yapabilecekleriniz ve yapamayacaklarınız.

Tamamlanmamış bir türle yapabilecekleriniz:

• Bir üyeyi işaretçi veya eksik türe başvuru olarak bildirin:

  class Foo {
      X *p;
      X &r;
  };

• Eksik türleri kabul eden / döndüren işlevleri veya yöntemleri bildirme :

  void f1(X);
  X    f2();

• Tamamlanmamış türe işaretçileri / referansları kabul eden / döndüren işlevleri veya yöntemleri tanımlayın (ancak üyelerini kullanmadan):

  void f3(X*, X&) {}
  X&   f4()       {}
  X*   f5()       {}

Tamamlanmamış bir türle yapamayacağınız şeyler:

• Temel sınıf olarak kullanın

  class Foo : X {} // compiler error!

• Bir üyeyi beyan etmek için kullanın:

  class Foo {
      X m; // compiler error!
  };

• Bu türü kullanarak işlevleri veya yöntemleri tanımlama

  void f1(X x) {} // compiler error!
  X    f2()    {} // compiler error!

• Yöntemlerini veya alanlarını kullanın, aslında tamamlanmamış türdeki bir değişkeni kaldırmaya çalışın

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

Şablonlar söz konusu olduğunda, mutlak bir kural yoktur: eksik bir türü şablon parametresi olarak kullanıp kullanamayacağınız, türün şablonda kullanılma şekline bağlıdır.

Örneğin std::vector<T>, parametresinin tam bir tür olmasını gerektirir, ancak boost::container::vector<T>öyle olmaz. Bazen, yalnızca belirli üye işlevlerini kullanıyorsanız tam bir tür gerekir; mesela bu böyledirstd::unique_ptr<T> .

İyi belgelenmiş bir şablon, belgelerinde tam tür olması gerekip gerekmediği de dahil olmak üzere parametrelerinin tüm gereksinimlerini belirtmelidir.

Ana kural, yalnızca bellek düzeninin (ve dolayısıyla üye işlevleri ve veri üyelerinin) ilettiğiniz dosyada bilinmesi gerekmeyen sınıfları iletebilmenizdir.

Bu, temel sınıfları ve referanslar ve işaretçilerle kullanılan sınıflar dışında her şeyi dışlar.

Lakos sınıf kullanımı arasında ayrım yapar

1. in-adı okunur (ileri bir beyan yeterli) ve
2. boyut olarak (sınıf tanımının gerekli olduğu).

Daha özlü olarak telaffuz edildiğini hiç görmedim :)

Eksik türlere yönelik işaretçilerin ve referansların yanı sıra, eksik tür olan parametreleri ve / veya dönüş değerlerini belirten işlev prototipleri de bildirebilirsiniz. Ancak, bir işaretçi veya başvuru olmadığı sürece, tamamlanmamış bir parametre veya dönüş türüne sahip bir işlevi tanımlayamazsınız .

Örnekler:

struct X;              // Forward declaration of X

void f1(X* px) {}      // Legal: can always use a pointer
void f2(X&  x) {}      // Legal: can always use a reference
X f3(int);             // Legal: return value in function prototype
void f4(X);            // Legal: parameter in function prototype
void f5(X) {}          // ILLEGAL: *definitions* require complete types

Şimdiye kadar cevapların hiçbiri, bir sınıf şablonunun ne zaman ileri bir bildirimini kullanabileceğini açıklamaz. Yani, işte gidiyor.

Bir sınıf şablonu şu şekilde bildirilebilir:

template <typename> struct X;

Kabul edilen cevabın yapısını takiben ,

İşte yapabilecekleriniz ve yapamayacaklarınız.

Tamamlanmamış bir türle yapabilecekleriniz:

• Bir üyeyi başka bir sınıf şablonundaki işaretçi veya eksik türe başvuru olarak bildirin:

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

• Bir üyeyi işaretçi veya eksik örneklerinden birine başvuru olarak bildirin:

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

• Eksik türleri kabul eden / döndüren işlev şablonları veya üye işlev şablonları bildirme:

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

• Eksik örneklerinden birini kabul eden / döndüren işlevler veya üye işlevler bildirme:

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

• Tamamlanmamış türe işaretçileri / referansları kabul eden / döndüren işlev şablonlarını veya üye işlev şablonlarını tanımlayın (ancak üyelerini kullanmadan):

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

• Eksik örneklerinden birine (ancak üyelerini kullanmadan) işaretçileri / referansları kabul eden / döndüren işlevleri veya yöntemleri tanımlayın:

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

• Başka bir şablon sınıfının temel sınıfı olarak kullanın

  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.

• Başka bir sınıf şablonunun bir üyesini bildirmek için kullanın:

  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.

• Bu türü kullanarak işlev şablonlarını veya yöntemleri tanımlama

  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
  }

Tamamlanmamış bir türle yapamayacağınız şeyler:

• Örneklerinden birini temel sınıf olarak kullanma

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

• Bir üyeyi beyan etmek için örneklerinden birini kullanın:

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

• Örneklerinden birini kullanarak işlevleri veya yöntemleri tanımlama

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

• Gerçekleştirilen türlerden birinin yöntemlerini veya alanlarını kullanın, aslında tamamlanmamış türdeki bir değişkeni kaldırmaya çalışın

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

• Sınıf şablonunun açık örneklerini oluşturma

  template struct X<int>;

İçinde yalnızca İşaretçi'yi veya bir sınıfa Başvuruyu kullandığınız dosyada ve bu İşaretçi / başvuruyu düşünerek hiçbir üye / üye işlevi çağrılmamalıdır.

ile class Foo; // ileri beyanı

Foo * veya Foo & türündeki veri üyelerini bildirebiliriz.

İşlevleri Foo türünde argümanlar ve / veya döndürme değerleri ile bildirebiliriz (ancak tanımlayamayız).

Foo türündeki statik veri üyelerini bildirebiliriz. Bunun nedeni, statik veri üyelerinin sınıf tanımının dışında tanımlanmasıdır.

Bunu sadece bir yorumdan ziyade ayrı bir cevap olarak yazıyorum çünkü yasallık temelinde değil, sağlam yazılım ve yanlış yorumlanma tehlikesi nedeniyle Luc Touraille'in cevabına katılmıyorum.

Özellikle, arayüzünüzün kullanıcılarının bilmesini beklediğiniz şeyle ilgili zımni sözleşme ile ilgili bir sorunum var.

Referans türlerini iade ediyorsanız veya kabul ediyorsanız, sadece bir işaretçi veya referanstan geçebildiklerini söylüyorsunuz, bu da sadece ileri bir bildirim yoluyla bildikleri anlamına gelir.

Eğer tamamlanmamış bir türü döndüren zaman X f2();sonra arayan söylediğini mutlaka X'in tam tür özelliklerine sahip Çağrı sitesinde LHS veya geçici nesne oluşturmak için buna ihtiyaç duyuyorlar.

Benzer şekilde, eksik bir türü kabul ederseniz, arayanın parametre olan nesneyi oluşturması gerekir. Bu nesne bir işlevden eksik başka bir tür olarak döndürülse bile, çağrı sitesi tam bildirime ihtiyaç duyar. yani:

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

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

Bir üstbilginin, diğer üstbilgileri gerektiren bir bağımlılık olmadan kullanmak için yeterli bilgi sağlaması gerektiği önemli bir ilke olduğunu düşünüyorum. Bu, bildirdiği herhangi bir işlevi kullandığınızda başlık derleyici birimine derleme hatasına neden olmadan eklenebileceği anlamına gelir.

Dışında

1. Bu dış bağımlılık isteniyorsa davranış. Koşullu derleme kullanmak yerine, X bildiren kendi başlıklarını sağlamaları için iyi belgelenmiş bir gereksiniminiz olabilir.

2. Önemli bir ayrım, onları somutlaştırmamanız gereken bazı şablon teknikleridir, sadece birisinin benimle sersemlememesi için bahsedilmiştir.

İzlediğim genel kural, zorunlu olmadıkça herhangi bir başlık dosyası eklememektir. Bu yüzden, bir sınıfın nesnesini sınıfımın üye değişkeni olarak saklamıyorsam, onu dahil etmeyeceğim, sadece ileri bildirimi kullanacağım.

Tanıma ihtiyaç duymadığınız sürece (düşünme işaretçileri ve referanslar) ileri bildirimlerden kurtulabilirsiniz. Uygulama dosyaları genellikle uygun tanım (lar) için üstbilgiyi alırken, çoğunlukla onları başlıklarda görürsünüz.

Sınıfın bir üyesi olarak diğer türü (sınıf) kullanmak istediğinizde genellikle bir sınıf üstbilgisi dosyasında ileri bildirimi kullanmak isteyeceksiniz. Üstbilgi dosyasında ileri bildirilen sınıflar yöntemlerini kullanamazsınız, çünkü C ++ o sınıfın tanımını o noktada henüz bilmiyor. Bu, .cpp dosyalarına taşınmanız gereken mantıktır, ancak şablon işlevlerini kullanıyorsanız, bunları yalnızca şablonu kullanan parçaya indirmeli ve bu işlevi başlığa taşımalısınız.

İleri bildirimin kodunuzun derlenmesini sağlayacağını düşünün (obj oluşturulur). Bununla birlikte, tanımlar bulunmadıkça (exe oluşturma) bağlantı başarılı olmaz.

Luc Touraille'in cevabında belirtilmeyen bir ileri sınıfla yapabileceğiniz önemli bir şey eklemek istiyorum.

Tamamlanmamış bir türle yapabilecekleriniz:

İşaretçileri / tamamlanmamış tipe başvuruları kabul eden / döndüren işlevleri veya yöntemleri tanımlayın ve bu işaretçileri / başvuruları başka bir işleve iletin.

void  f6(X*)       {}
void  f7(X&)       {}
void  f8(X* x_ptr, X& x_ref) { f6(x_ptr); f7(x_ref); }

Bir modül ileri bildirilen sınıftaki bir nesneden başka bir modüle geçebilir.

Luc Touraille, sınıfın ileri bildirimini nerede kullanacağını ve kullanmamasını çoktan açıkladı.

Sadece neden kullanmamız gerektiğini ekleyeceğim.

İstenmeyen bağımlılık enjeksiyonundan kaçınmak için mümkün olduğunda İleri bildirimi kullanmalıyız.

Gibi #includebaşlık dosyaları bu nedenle birden çok dosya üzerinde eklenir biz başka başlık dosyasına bir başlık eklerseniz, o ekleyerek önlenebilir kaynak kodu çeşitli yerlerinde istenmeyen bağımlılık enjeksiyon katacak #includeiçine başlığını .cppdosyaları mümkün olduğunca yerine başka başlık dosyasına eklenmesi ve başlık .hdosyalarında mümkün olduğunda sınıf ileri bildirimini kullanın .