Haruskah kita menambahkan konstruktor ke struct?

Kami sering menggunakan c ++ struct untuk mendefinisikan struktur data sebagai lawan dari kelas yang dapat menjadi modul lengkap dengan metode anggota. Sekarang jauh di lubuk hati, kita tahu mereka berdua sama (secara longgar).

Fakta bahwa kita sering menggunakan / memperlakukan struct sebagai entitas data saja menciptakan desakan ini bahwa kita juga tidak menambahkan konstruktor default. Tetapi konstruktor selalu bagus, mereka membuat hal-hal sederhana dan membantu menghilangkan kesalahan.

Apakah akan disukai jika menambahkan konstruktor default ke struktur data saya?

Apakah menerapkan konstruktor default juga membuat struct Non-POD (tipe data lama biasa) asalkan kriteria lain terpenuhi?

Untuk menempatkan hal-hal dalam perspektif, pertimbangkan contoh sederhana tetapi dalam kenyataannya struct akan jauh lebih besar.

struct method
{
    char    name[32];
    float   temperature;
    int     duration;
};

Setiap kali saya membuat metode, saya harus khawatir tentang (untuk sedikitnya) jika saya lupa menetapkan beberapa nilai. Bayangkan saya lupa mengatur temperaturedan menerapkan metode ke sistem yang sekarang menjadi nilai tinggi acak dan menyebabkan kekacauan. Atau saya lupa mengatur durationdan sekarang metode ini berlaku untuk durasi tinggi yang tidak diketahui.

Mengapa saya harus bertanggung jawab untuk menginisialisasi objek setiap kali alih-alih mengimplementasikan konstruktornya yang menjaminnya?

Terkadang lebih tepat untuk menambahkan konstruktor ke struct dan kadang-kadang tidak.

Menambahkan konstruktor (konstruktor apa saja) ke struct mencegah penggunaan initializer agregat di atasnya. Jadi, jika Anda menambahkan konstruktor default, Anda juga harus mendefinisikan konstruktor non-default menginisialisasi nilai. Tetapi jika Anda ingin memastikan bahwa Anda selalu menginisialisasi semua anggota, itu tepat.

Menambahkan konstruktor (konstruktor apa saja, sekali lagi) membuatnya non-POD, tetapi dalam C ++ 11 sebagian besar aturan yang sebelumnya diterapkan ke POD hanya diubah untuk diterapkan ke objek tata letak standar dan menambahkan konstruktor tidak merusaknya. Jadi penginisialisasi agregat pada dasarnya adalah satu-satunya hal yang Anda kehilangan. Tetapi itu juga sering merupakan kerugian besar.

Dengan C ++ 11 bisa Anda lakukan

struct method
{
    char    name[32] {};
    float   temperature = 42.141521;
    int     duration = -6;
};

Dan setiap kali Anda lupa untuk menginisialisasi sesuatu, Anda mendapatkan inisialisasi default.

Jawaban cepat:

Itu tergantung pada apa yang ingin Anda capai.

Panjang, Diperpanjang, Jawaban Membosankan:

Anda memukul paku.

Saya biasanya tidak suka bahwa "C ++" memungkinkan "Struct (s)" memungkinkan untuk mendeklarasikan metode. Lebih disukai, saya menggunakan eksplisit "Kelas (es)" untuk metode yang diperlukan dan POD "Struct (s)" untuk bidang saja.

Namun, saya setuju bahwa beberapa operasi sederhana dasar, seperti:

• tetapkan nilai awal ("konstruktor")
• membuat salinan struktur ("copy constructor)
• menetapkan nilai ke struktur yang ada ("operator penetapan overload")

Diperlukan, dan, dalam keadaan itu, metode untuk struktur, masuk akal.

Saran

Solusi potensial lainnya adalah dengan menggunakan struktur POD, tetapi, masih secara konseptual memperlakukan mereka sebagai kelas dan objek.

Bungkus deklarasi tersebut dalam namespace, dan, tambahkan fungsi global, untuk tindakan yang paling penting.

Deklarasi kode dapat serupa dengan ini:

namespace Customers
{
  struct CustomerStruct
  {
    char[255] FirstName;
    char[255] LastName;
    int Age;
    bool IsAlive;
    bool IsMarried;
  }; // struct

  CustomerStruct* CreateCustomer
  (
    char* NewFirstName;
    char* NewLastName;
    int NewAge;
    bool NewIsAlive;
    bool NewIsMarried;
  )
  {
    CustomerStruct* NewCustomer = new CustomerStruct();
      NewCustomer->FirstName = NewFirstName;
      NewCustomer->LastName = NewLastName;
      NewCustomer->Age = NewAge;
      NewCustomer->IsAlive = NewIsAlive;
      NewCustomer->IsMarried = NewIsMarried;
    return NewCustomer;
  } // CustomerStruct* CreateCustomer (...)

} // namespace

Kode yang menerapkan solusi, bisa jadi seperti ini:

#include <Customers>

using Customers;

int main (...)
{
   int ErrorCode = 0;

   CustomerClass* ThisCustomer =
     Customers::CreateCustomer
      ("John", "Doe", 23, true, true);

   // do something with "ThisCustomer"

   delete ThisCustomer;

   return ErrorCode;
} // int main(...)

Pendekatan alternatif ini lebih baik ketika alokasi memori data yang besar diperlukan, atau berinteraksi dengan perpustakaan bersama tingkat rendah lainnya.

Pendekatan ini, dengan beberapa perubahan, diterapkan dalam Pengembangan Game.

Tambahan

Secara pribadi, saya mempertimbangkan ekstensi sintaksis untuk "C ++", atau bahkan, PL berbasis "C ++" baru yang memecahkan masalah ini:

// "Plain Old Data" Structure
// No Methods, No "Functors", allowed
strict struct CustomerStruct
{
  char[255] FirstName;
  char[255] LastName;
  int Age;
  bool IsAlive;
  bool IsMarried;
}; // strict struct

// Object Oriented "Plain Old Data" Structure
// Yes, Methods and "Functors" allowed
relaxed struct CustomerStruct
{
  char[255] FirstName;
  char[255] LastName;
  int Age;
  bool IsAlive;
  bool IsMarried;

  public void Foo();
  public void Bar();

  public (void*) (SomeFunctor) ();
}; // relaxed struct

// Class and Object Oriented
class CustomerClass
{
  public char[255] FirstName;
  public char[255] LastName;
  public int Age;
  public bool IsAlive;
  public bool IsMarried;

  public void Foo();
  public void Bar();
}; // class

Bersulang.