Apakah C ++ 11 memiliki properti bergaya C #?

Di C #, ada gula sintaks yang bagus untuk bidang dengan pengambil dan penyetel. Selain itu, saya menyukai properti yang diimplementasikan secara otomatis yang memungkinkan saya untuk menulis

public Foo foo { get; private set; }

Di C ++ saya harus menulis

private:
    Foo foo;
public:
    Foo getFoo() { return foo; }

Apakah ada beberapa konsep seperti itu di C ++ 11 yang memungkinkan saya memiliki beberapa gula sintaks dalam hal ini?

Di C ++ Anda dapat menulis fitur Anda sendiri. Berikut adalah contoh implementasi properti menggunakan kelas tanpa nama. Artikel Wikipedia

struct Foo
{
    class {
        int value;
        public:
            int & operator = (const int &i) { return value = i; }
            operator int () const { return value; }
    } alpha;

    class {
        float value;
        public:
            float & operator = (const float &f) { return value = f; }
            operator float () const { return value; }
    } bravo;
};

Anda dapat menulis getter & setter Anda sendiri di tempatnya dan jika Anda ingin akses anggota kelas pemegang, Anda dapat memperluas kode contoh ini.

C ++ tidak memiliki bawaan ini, Anda dapat menentukan template untuk meniru fungsionalitas properti:

template <typename T>
class Property {
public:
    virtual ~Property() {}  //C++11: use override and =default;
    virtual T& operator= (const T& f) { return value = f; }
    virtual const T& operator() () const { return value; }
    virtual explicit operator const T& () const { return value; }
    virtual T* operator->() { return &value; }
protected:
    T value;
};

Untuk mendefinisikan properti :

Property<float> x;

Untuk mengimplementasikan pengambil / penyetel khusus cukup mewarisi:

class : public Property<float> {
    virtual float & operator = (const float &f) { /*custom code*/ return value = f; }
    virtual operator float const & () const { /*custom code*/ return value; }
} y;

Untuk mendefinisikan properti read-only :

template <typename T>
class ReadOnlyProperty {
public:
    virtual ~ReadOnlyProperty() {}
    virtual operator T const & () const { return value; }
protected:
    T value;
};

Dan untuk menggunakannya di kelasOwner :

class Owner {
public:
    class : public ReadOnlyProperty<float> { friend class Owner; } x;
    Owner() { x.value = 8; }
};

Anda dapat menentukan beberapa hal di atas dalam makro agar lebih ringkas.

Tidak ada dalam bahasa C ++ yang akan berfungsi di semua platform dan kompiler.

Tetapi jika Anda ingin merusak kompatibilitas lintas platform dan berkomitmen untuk kompiler tertentu, Anda mungkin dapat menggunakan sintaks tersebut, misalnya di Microsoft Visual C ++ Anda dapat melakukannya

// declspec_property.cpp  
struct S {  
   int i;  
   void putprop(int j) {   
      i = j;  
   }  

   int getprop() {  
      return i;  
   }  

   __declspec(property(get = getprop, put = putprop)) int the_prop;  
};  

int main() {  
   S s;  
   s.the_prop = 5;  
   return s.the_prop;  
}

Anda dapat meniru pengambil dan penyetel sampai batas tertentu dengan memiliki anggota tipe khusus dan menimpa operator(type)dan operator=untuk itu. Apakah itu ide yang bagus adalah pertanyaan lain dan saya akan +1menjawab jawaban Kerrek SB untuk mengungkapkan pendapat saya atasnya :)

Mungkin lihatlah kelas properti yang telah saya kumpulkan selama beberapa jam terakhir: /codereview/7786/c11-feedback-on-my-approach-to-c-like-class-properties

Ini memungkinkan Anda memiliki properti yang berperilaku seperti ini:

CTestClass myClass = CTestClass();

myClass.AspectRatio = 1.4;
myClass.Left = 20;
myClass.Right = 80;
myClass.AspectRatio = myClass.AspectRatio * (myClass.Right - myClass.Left);

Dengan C ++ 11 Anda dapat menentukan template kelas Properti dan menggunakannya seperti ini:

class Test{
public:
  Property<int, Test> Number{this,&Test::setNumber,&Test::getNumber};

private:
  int itsNumber;

  void setNumber(int theNumber)
    { itsNumber = theNumber; }

  int getNumber() const
    { return itsNumber; }
};

Dan inilah template kelas Property.

template<typename T, typename C>
class Property{
public:
  using SetterType = void (C::*)(T);
  using GetterType = T (C::*)() const;

  Property(C* theObject, SetterType theSetter, GetterType theGetter)
   :itsObject(theObject),
    itsSetter(theSetter),
    itsGetter(theGetter)
    { }

  operator T() const
    { return (itsObject->*itsGetter)(); }

  C& operator = (T theValue) {
    (itsObject->*itsSetter)(theValue);
    return *itsObject;
  }

private:
  C* const itsObject;
  SetterType const itsSetter;
  GetterType const itsGetter;
};

Seperti yang telah dikatakan banyak orang lain, tidak ada dukungan bawaan dalam bahasa tersebut. Namun, jika Anda menargetkan kompiler Microsoft C ++, Anda dapat memanfaatkan ekstensi khusus Microsoft untuk properti yang didokumentasikan di sini.

Ini adalah contoh dari halaman tertaut:

// declspec_property.cpp
struct S {
   int i;
   void putprop(int j) { 
      i = j;
   }

   int getprop() {
      return i;
   }

   __declspec(property(get = getprop, put = putprop)) int the_prop;
};

int main() {
   S s;
   s.the_prop = 5;
   return s.the_prop;
}

Tidak, C ++ tidak memiliki konsep properti. Meskipun sulit untuk mendefinisikan dan memanggil getThis () atau setThat (value), Anda membuat pernyataan kepada konsumen dari metode tersebut bahwa beberapa fungsionalitas dapat terjadi. Mengakses bidang di C ++, di sisi lain, memberi tahu konsumen bahwa tidak ada fungsionalitas tambahan atau tak terduga yang akan terjadi. Properti akan membuat hal ini kurang jelas karena akses properti pada pandangan pertama tampak bereaksi seperti bidang, tetapi pada kenyataannya bereaksi seperti metode.

Selain itu, saya bekerja di aplikasi .NET (CMS yang sangat terkenal) mencoba membuat sistem keanggotaan pelanggan. Karena cara mereka menggunakan properti untuk objek pengguna mereka, tindakan dijalankan yang tidak saya antisipasi, menyebabkan implementasi saya dieksekusi dengan cara yang aneh termasuk rekursi tak terbatas. Ini karena objek penggunanya melakukan panggilan ke lapisan akses data atau beberapa sistem cache global saat mencoba mengakses hal-hal sederhana seperti StreetAddress. Seluruh sistem mereka didasarkan pada apa yang saya sebut sebagai penyalahgunaan properti. Seandainya mereka menggunakan metode alih-alih properti, saya pikir saya akan lebih cepat mengetahui apa yang salah. Seandainya mereka telah menggunakan bidang (atau setidaknya membuat properti mereka berperilaku lebih seperti bidang), saya pikir sistem akan lebih mudah untuk diperluas dan dipelihara.

[Sunting] Mengubah pikiran saya. Aku mengalami hari yang buruk dan sedikit mengomel. Pembersihan ini harus lebih profesional.

Berdasarkan https://stackoverflow.com/a/23109533/404734, berikut adalah versi dengan pengambil publik dan penyetel pribadi:

struct Foo
{
    class
    {
            int value;
            int& operator= (const int& i) { return value = i; }
            friend struct Foo;
        public:
            operator int() const { return value; }
    } alpha;
};

Ini sebenarnya bukan properti, tetapi melakukan apa yang Anda inginkan dengan cara sederhana:

class Foo {
  int x;
public:
  const int& X;
  Foo() : X(x) {
    ...
  }
};

Di sini X besar berperilaku seperti public int X { get; private set; }dalam sintaks C #. Jika Anda menginginkan properti full-blown, saya membuat bidikan pertama untuk menerapkannya di sini .

Anda mungkin tahu itu tetapi saya hanya akan melakukan hal berikut:

class Person {
public:
    std::string name() {
        return _name;
    }
    void name(std::string value) {
        _name = value;
    }
private:
    std::string _name;
};

Pendekatan ini sederhana, tidak menggunakan trik cerdas dan menyelesaikan pekerjaan!

Masalahnya adalah bahwa beberapa orang tidak suka memberi awalan bidang pribadi mereka dengan garis bawah sehingga mereka tidak dapat benar-benar menggunakan pendekatan ini, tetapi untungnya bagi mereka yang melakukannya, ini sangat mudah. :)

Dapatkan dan setel prefiks tidak menambah kejelasan pada API Anda tetapi membuatnya lebih bertele-tele dan alasan saya rasa mereka tidak menambahkan informasi yang berguna adalah karena ketika seseorang perlu menggunakan API jika API masuk akal, dia mungkin akan menyadari apa itu tidak tanpa awalan.

Satu hal lagi, mudah untuk memahami bahwa ini adalah properti karena namebukan kata kerja.

Skenario terburuk, jika API konsisten dan orang tersebut tidak menyadari bahwa itu name()adalah aksesor dan name(value)mutator maka dia hanya perlu mencarinya sekali dalam dokumentasi untuk memahami polanya.

Sebanyak saya suka C # Saya rasa C ++ tidak membutuhkan properti sama sekali!

Tidak .. Tetapi Anda harus mempertimbangkan jika hanya get: set function dan tidak ada tugas tambahan yang dibentuk sebelumnya di dalam get: set, buat saja menjadi publik.

Saya mengumpulkan ide-ide dari beberapa sumber C ++ dan memasukkannya ke dalam contoh yang bagus, masih cukup sederhana untuk getter / setter di C ++:

class Canvas { public:
    void resize() {
        cout << "resize to " << width << " " << height << endl;
    }

    Canvas(int w, int h) : width(*this), height(*this) {
        cout << "new canvas " << w << " " << h << endl;
        width.value = w;
        height.value = h;
    }

    class Width { public:
        Canvas& canvas;
        int value;
        Width(Canvas& canvas): canvas(canvas) {}
        int & operator = (const int &i) {
            value = i;
            canvas.resize();
            return value;
        }
        operator int () const {
            return value;
        }
    } width;

    class Height { public:
        Canvas& canvas;
        int value;
        Height(Canvas& canvas): canvas(canvas) {}
        int & operator = (const int &i) {
            value = i;
            canvas.resize();
            return value;
        }
        operator int () const {
            return value;
        }
    } height;
};

int main() {
    Canvas canvas(256, 256);
    canvas.width = 128;
    canvas.height = 64;
}

Keluaran:

new canvas 256 256
resize to 128 256
resize to 128 64

Anda dapat mengujinya secara online di sini: http://codepad.org/zosxqjTX

Apakah kelas Anda benar-benar perlu memberlakukan beberapa invarian atau apakah itu hanya pengelompokan logis dari elemen anggota? Jika yang terakhir, Anda harus mempertimbangkan untuk membuat hal itu menjadi struct dan mengakses anggota secara langsung.

Ada satu set makro yang tertulis di sini . Ini memiliki deklarasi properti yang nyaman untuk tipe nilai, tipe referensi, tipe hanya baca, tipe kuat dan tipe lemah.

class MyClass {

 // Use assign for value types.
 NTPropertyAssign(int, StudentId)

 public:
 ...

}