Kapan saya bisa menggunakan deklarasi maju?

Saya mencari definisi kapan saya diizinkan untuk melakukan penerusan deklarasi suatu kelas dalam file header kelas lain:

Apakah saya boleh melakukannya untuk kelas dasar, untuk kelas yang diadakan sebagai anggota, untuk kelas yang diteruskan ke fungsi anggota dengan referensi, dll.?

Tempatkan diri Anda pada posisi kompiler: ketika Anda meneruskan mendeklarasikan suatu tipe, yang diketahui kompiler adalah bahwa tipe ini ada; ia tidak tahu apa-apa tentang ukuran, anggota, atau metode. Inilah sebabnya mengapa ini disebut tipe tidak lengkap . Oleh karena itu, Anda tidak dapat menggunakan tipe untuk mendeklarasikan anggota, atau kelas dasar, karena kompiler perlu mengetahui tata letak tipe tersebut.

Dengan asumsi deklarasi maju berikut.

class X;

Inilah yang bisa dan tidak bisa Anda lakukan.

Apa yang dapat Anda lakukan dengan jenis yang tidak lengkap:

• Nyatakan anggota sebagai penunjuk atau referensi ke tipe tidak lengkap:

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

• Menyatakan fungsi atau metode yang menerima / mengembalikan tipe tidak lengkap:

  void f1(X);
  X    f2();
  

• Tetapkan fungsi atau metode yang menerima / mengembalikan pointer / referensi ke tipe tidak lengkap (tetapi tanpa menggunakan anggotanya):

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

Apa yang tidak dapat Anda lakukan dengan jenis yang tidak lengkap:

• Gunakan itu sebagai kelas dasar

  class Foo : X {} // compiler error!

• Gunakan itu untuk mendeklarasikan anggota:

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

• Tentukan fungsi atau metode menggunakan tipe ini

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

• Gunakan metode atau bidangnya, sebenarnya mencoba untuk mengubah variabel dengan tipe tidak lengkap

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

Ketika datang ke template, tidak ada aturan absolut: apakah Anda dapat menggunakan tipe yang tidak lengkap karena parameter template tergantung pada cara tipe tersebut digunakan dalam template.

Misalnya, std::vector<T>mengharuskan parameternya menjadi tipe lengkap, sementara boost::container::vector<T>tidak. Terkadang, tipe yang lengkap diperlukan hanya jika Anda menggunakan fungsi anggota tertentu; ini adalah kasus untukstd::unique_ptr<T> , misalnya.

Templat yang terdokumentasi dengan baik harus menunjukkan dalam dokumentasinya semua persyaratan parameternya, termasuk apakah mereka perlu tipe yang lengkap atau tidak.

Aturan utamanya adalah bahwa Anda hanya dapat meneruskan kelas yang tata letak memorinya (dan dengan demikian fungsi anggota dan anggota data) tidak perlu diketahui dalam file yang Anda forwardkan mendeklarasikannya.

Ini akan mengesampingkan kelas dasar dan apa pun kecuali kelas yang digunakan melalui referensi dan petunjuk.

Lakos membedakan antara penggunaan kelas

1. in-name-only (yang deklarasi majunya memadai) dan
2. dalam ukuran (yang membutuhkan definisi kelas).

Saya belum pernah melihatnya diucapkan dengan lebih ringkas :)

Selain petunjuk dan referensi ke tipe tidak lengkap, Anda juga dapat mendeklarasikan prototipe fungsi yang menentukan parameter dan / atau mengembalikan nilai yang merupakan tipe tidak lengkap. Namun, Anda tidak dapat menentukan fungsi yang memiliki parameter atau tipe pengembalian yang tidak lengkap, kecuali itu adalah pointer atau referensi.

Contoh:

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

Sejauh ini tidak ada jawaban yang menjelaskan kapan orang bisa menggunakan deklarasi templat kelas yang diteruskan. Jadi begini saja.

Templat kelas dapat diteruskan dinyatakan sebagai:

template <typename> struct X;

Mengikuti struktur jawaban yang diterima ,

Inilah yang bisa dan tidak bisa Anda lakukan.

Apa yang dapat Anda lakukan dengan jenis yang tidak lengkap:

• Menyatakan anggota untuk menjadi penunjuk atau referensi ke tipe tidak lengkap di templat kelas lain:

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

• Nyatakan anggota sebagai penunjuk atau referensi ke salah satu instantiasinya yang tidak lengkap:

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

• Nyatakan templat fungsi atau templat fungsi anggota yang menerima / mengembalikan tipe tidak lengkap:

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

• Menyatakan fungsi atau fungsi anggota yang menerima / mengembalikan salah satu instantiasinya yang tidak lengkap:

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

• Tentukan templat fungsi atau templat fungsi anggota yang menerima / mengembalikan pointer / referensi ke tipe tidak lengkap (tetapi tanpa menggunakan anggotanya):

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

• Tetapkan fungsi atau metode yang menerima / mengembalikan pointer / referensi ke salah satu instantiasinya yang tidak lengkap (tetapi tanpa menggunakan anggotanya):

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

• Gunakan itu sebagai kelas dasar dari kelas template lain

  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.
  

• Gunakan untuk mendeklarasikan anggota templat kelas lain:

  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.
  

• Tentukan templat fungsi atau metode menggunakan jenis ini

  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
  }
  

Apa yang tidak dapat Anda lakukan dengan jenis yang tidak lengkap:

• Gunakan salah satu instantiasinya sebagai kelas dasar

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

• Gunakan salah satu instantiasinya untuk mendeklarasikan anggota:

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

• Tetapkan fungsi atau metode menggunakan salah satu instantiasinya

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

• Gunakan metode atau bidang dari salah satu instantiasinya, pada kenyataannya mencoba meredereferensi variabel dengan tipe tidak lengkap

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

• Buat instantiasi eksplisit dari templat kelas

  template struct X<int>;

Dalam file di mana Anda hanya menggunakan Pointer atau Referensi ke suatu kelas. Dan tidak ada fungsi anggota / anggota yang harus dipikirkan jika Pointer / referensi tersebut.

dengan class Foo;// meneruskan deklarasi

Kami dapat mendeklarasikan data anggota tipe Foo * atau Foo &.

Kami dapat mendeklarasikan (tetapi tidak mendefinisikan) fungsi dengan argumen, dan / atau mengembalikan nilai, dari tipe Foo.

Kami dapat mendeklarasikan anggota data statis tipe Foo. Ini karena anggota data statis didefinisikan di luar definisi kelas.

Saya menulis ini sebagai jawaban terpisah daripada hanya komentar karena saya tidak setuju dengan jawaban Luc Touraille, bukan karena alasan legalitas tetapi untuk perangkat lunak yang kuat dan bahaya salah tafsir.

Secara khusus, saya memiliki masalah dengan kontrak tersirat tentang apa yang Anda harapkan agar diketahui oleh pengguna antarmuka Anda.

Jika Anda mengembalikan atau menerima jenis referensi, maka Anda hanya mengatakan mereka dapat melewati pointer atau referensi yang mereka mungkin hanya tahu melalui deklarasi maju.

Ketika Anda mengembalikan jenis yang tidak lengkap X f2();maka Anda mengatakan penelepon Anda harus memiliki spesifikasi tipe lengkap X. Mereka membutuhkannya untuk membuat LHS atau objek sementara di situs panggilan.

Demikian pula, jika Anda menerima jenis yang tidak lengkap, pemanggil harus membuat objek yang merupakan parameter. Bahkan jika objek itu dikembalikan sebagai tipe lain yang tidak lengkap dari suatu fungsi, situs panggilan membutuhkan deklarasi penuh. yaitu:

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

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

Saya pikir ada prinsip penting bahwa header harus menyediakan informasi yang cukup untuk menggunakannya tanpa ketergantungan yang membutuhkan header lainnya. Itu berarti tajuk harus dapat dimasukkan dalam unit kompilasi tanpa menyebabkan kesalahan kompiler ketika Anda menggunakan fungsi yang dinyatakannya.

Kecuali

1. Jika ketergantungan eksternal ini perilaku yang diinginkan . Alih-alih menggunakan kompilasi bersyarat Anda bisa memiliki persyaratan yang terdokumentasi dengan baik bagi mereka untuk menyediakan header mereka sendiri yang menyatakan X. Ini adalah alternatif untuk menggunakan #ifdefs dan dapat menjadi cara yang berguna untuk memperkenalkan tiruan atau varian lainnya.

2. Perbedaan penting adalah beberapa teknik templat di mana Anda secara eksplisit TIDAK diharapkan untuk membuat instantiate, disebutkan hanya supaya seseorang tidak marah kepada saya.

Aturan umum yang saya ikuti adalah untuk tidak menyertakan file header apa pun kecuali saya harus. Jadi, kecuali saya menyimpan objek kelas sebagai variabel anggota kelas saya, saya tidak akan memasukkannya, saya hanya akan menggunakan deklarasi maju.

Selama Anda tidak membutuhkan definisi (pikirkan petunjuk dan referensi), Anda bisa lolos dengan deklarasi maju. Inilah sebabnya mengapa sebagian besar Anda akan melihatnya di header sementara file implementasi biasanya akan menarik header untuk definisi yang tepat.

Anda biasanya ingin menggunakan deklarasi maju dalam file header kelas ketika Anda ingin menggunakan tipe lain (kelas) sebagai anggota kelas. Anda tidak dapat menggunakan metode kelas yang dinyatakan maju dalam file header karena C ++ belum mengetahui definisi kelas itu pada saat itu. Itu logika Anda harus pindah ke file .cpp, tetapi jika Anda menggunakan fungsi template Anda harus mengurangi mereka hanya bagian yang menggunakan template dan memindahkan fungsi itu ke header.

Ambillah bahwa deklarasi maju akan membuat kode Anda dikompilasi (obj dibuat). Namun menghubungkan (penciptaan exe) tidak akan berhasil kecuali definisi yang ditemukan.

Saya hanya ingin menambahkan satu hal penting yang dapat Anda lakukan dengan kelas yang diteruskan tidak disebutkan dalam jawaban Luc Touraille.

Apa yang dapat Anda lakukan dengan jenis yang tidak lengkap:

Tetapkan fungsi atau metode yang menerima / mengembalikan pointer / referensi ke tipe tidak lengkap dan meneruskan pointer / referensi ke fungsi lain.

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

Modul dapat melewati objek kelas yang dinyatakan maju ke modul lain.

Seperti, Luc Touraille telah menjelaskan dengan sangat baik di mana harus digunakan dan tidak menggunakan pernyataan maju kelas.

Saya hanya akan menambah alasan mengapa kita perlu menggunakannya.

Kita harus menggunakan deklarasi Teruskan sedapat mungkin untuk menghindari injeksi ketergantungan yang tidak diinginkan.

Karena #includefile header ditambahkan pada banyak file, oleh karena itu, jika kita menambahkan header ke file header lain, itu akan menambahkan injeksi ketergantungan yang tidak diinginkan di berbagai bagian kode sumber yang dapat dihindari dengan menambahkan #includeheader ke .cppfile di mana saja memungkinkan daripada menambahkan ke file header lain dan gunakan deklarasi forward class sedapat mungkin dalam .hfile header .