C ++ 11 มีคุณสมบัติ C # -style หรือไม่?

ใน C # มีน้ำตาลไวยากรณ์ที่ดีสำหรับฟิลด์ที่มี getter และ setter นอกจากนี้ฉันชอบคุณสมบัติที่ใช้งานอัตโนมัติซึ่งอนุญาตให้ฉันเขียนได้

public Foo foo { get; private set; }

ใน C ++ ฉันต้องเขียน

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

มีแนวคิดบางอย่างใน C ++ 11 ที่อนุญาตให้ฉันมีน้ำตาลไวยากรณ์ในเรื่องนี้หรือไม่

ใน C ++ คุณสามารถเขียนคุณสมบัติของคุณเองได้ นี่คือตัวอย่างการนำคุณสมบัติไปใช้โดยใช้คลาสที่ไม่มีชื่อ บทความ 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;
};

คุณสามารถเขียน getters & setters ของคุณเองได้และถ้าคุณต้องการเข้าถึงสมาชิกคลาสของผู้ถือคุณสามารถขยายโค้ดตัวอย่างนี้ได้

C ++ ไม่มีในตัวคุณสามารถกำหนดเทมเพลตเพื่อเลียนแบบคุณสมบัติการทำงาน:

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

ในการกำหนดคุณสมบัติ :

Property<float> x;

ในการใช้getter / setter ที่กำหนดเองเพียงแค่สืบทอด:

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;

ในการกำหนดคุณสมบัติอ่านอย่างเดียว :

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

และเพื่อใช้ในชั้นเรียนOwner :

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

คุณสามารถกำหนดบางส่วนข้างต้นในมาโครเพื่อให้กระชับมากขึ้น

ไม่มีสิ่งใดในภาษา C ++ ที่จะใช้ได้กับทุกแพลตฟอร์มและคอมไพเลอร์

แต่ถ้าคุณยินดีที่จะทำลายความเข้ากันได้ข้ามแพลตฟอร์มและยอมรับคอมไพเลอร์เฉพาะคุณอาจสามารถใช้ไวยากรณ์ดังกล่าวได้เช่นใน Microsoft Visual C ++คุณสามารถทำได้

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

คุณสามารถเลียนแบบ getter และ setter ได้ในระดับหนึ่งโดยให้สมาชิกประเภททุ่มเทและลบล้างoperator(type)และoperator=เพื่อมัน ไม่ว่าจะเป็นความคิดที่ดีเป็นคำถามอื่นหรือไม่และฉันจะ+1ตอบคำถามของ Kerrek SB เพื่อแสดงความคิดเห็นของฉัน :)

ด้วย C ++ 11 คุณสามารถกำหนดเทมเพลตคลาสคุณสมบัติและใช้งานได้ดังนี้:

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

และนี่คือเทมเพลตคลาสคุณสมบัติ

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

อาจลองดูคลาสคุณสมบัติที่ฉันรวบรวมในช่วงชั่วโมงที่แล้ว: /codereview/7786/c11-feedback-on-my-approach-to-c-like-class-properties

ช่วยให้คุณมีคุณสมบัติที่ทำงานเช่นนี้:

CTestClass myClass = CTestClass();

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

ดังที่หลายคนได้กล่าวไปแล้วไม่มีการรองรับภาษาในตัว อย่างไรก็ตามหากคุณกำหนดเป้าหมายไปที่คอมไพเลอร์ Microsoft C ++ คุณสามารถใช้ประโยชน์จากส่วนขยายเฉพาะของ Microsoft สำหรับคุณสมบัติที่มีการบันทึกไว้ที่นี่

นี่คือตัวอย่างจากหน้าที่เชื่อมโยง:

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

ไม่ C ++ ไม่มีแนวคิดเกี่ยวกับคุณสมบัติ แม้ว่าการกำหนดและเรียก getThis () หรือ setThat (value) อาจเป็นเรื่องที่ไม่สะดวก แต่คุณกำลังแถลงต่อผู้บริโภคเกี่ยวกับวิธีการเหล่านั้นว่าอาจมีฟังก์ชันบางอย่าง ในทางกลับกันการเข้าถึงฟิลด์ใน C ++ จะบอกผู้บริโภคว่าจะไม่มีฟังก์ชันเพิ่มเติมหรือไม่คาดคิดเกิดขึ้น คุณสมบัติจะทำให้สิ่งนี้ชัดเจนน้อยลงเนื่องจากการเข้าถึงคุณสมบัติในแวบแรกดูเหมือนว่าจะตอบสนองเหมือนเขตข้อมูล แต่ในความเป็นจริงจะตอบสนองเหมือนวิธีการ

นอกจากนี้ฉันยังทำงานในแอปพลิเคชัน. NET (CMS ที่รู้จักกันดี) เพื่อสร้างระบบสมาชิกของลูกค้า เนื่องจากวิธีที่พวกเขาใช้คุณสมบัติสำหรับออบเจ็กต์ผู้ใช้ของพวกเขาการดำเนินการจึงเกิดขึ้นโดยที่ฉันไม่คาดคิดทำให้การใช้งานของฉันดำเนินการในรูปแบบที่แปลกประหลาดรวมถึงการเรียกซ้ำที่ไม่สิ้นสุด นี่เป็นเพราะออบเจ็กต์ผู้ใช้ของพวกเขาทำการเรียกชั้นการเข้าถึงข้อมูลหรือระบบแคชส่วนกลางบางระบบเมื่อพยายามเข้าถึงสิ่งง่ายๆเช่น StreetAddress ระบบทั้งหมดของพวกเขาก่อตั้งขึ้นจากสิ่งที่ฉันเรียกว่าการละเมิดคุณสมบัติ หากพวกเขาใช้วิธีการแทนคุณสมบัติฉันคิดว่าฉันจะพบสิ่งที่ผิดพลาดได้เร็วขึ้น หากพวกเขาใช้ฟิลด์ (หรืออย่างน้อยก็ทำให้คุณสมบัติของมันทำงานเหมือนฟิลด์มากขึ้น) ฉันคิดว่าระบบน่าจะขยายและบำรุงรักษาได้ง่ายกว่า

[แก้ไข] เปลี่ยนความคิดของฉัน ฉันมีวันที่เลวร้ายและพูดคุยโวนิดหน่อย การล้างข้อมูลนี้ควรเป็นมืออาชีพมากขึ้น

อ้างอิงจากhttps://stackoverflow.com/a/23109533/404734นี่คือเวอร์ชันที่มี public getter และ private setter:

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

นี่ไม่ใช่คุณสมบัติ แต่ทำในสิ่งที่คุณต้องการด้วยวิธีง่ายๆ:

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

ที่นี่ X ขนาดใหญ่จะทำงานเหมือนpublic int X { get; private set; }ในไวยากรณ์ C # หากคุณต้องการคุณสมบัติเต็มเป่าผมทำยิงครั้งแรกจะใช้พวกเขาที่นี่

คุณอาจจะรู้ แต่ฉันจะทำสิ่งต่อไปนี้:

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

วิธีนี้ง่ายไม่ต้องใช้เทคนิคที่ชาญฉลาดและทำให้งานสำเร็จ!

แม้ว่าปัญหาคือบางคนไม่ชอบที่จะนำเขตข้อมูลส่วนตัวของตนด้วยเครื่องหมายขีดล่างดังนั้นพวกเขาจึงไม่สามารถใช้แนวทางนี้ได้ แต่โชคดีสำหรับคนเหล่านี้ที่ทำมันตรงไปตรงมาจริงๆ :)

คำนำหน้ารับและตั้งค่าไม่ได้เพิ่มความชัดเจนให้กับ API ของคุณ แต่ทำให้มีรายละเอียดมากขึ้นและเหตุผลที่ฉันไม่คิดว่าพวกเขาเพิ่มข้อมูลที่เป็นประโยชน์เพราะเมื่อมีคนต้องการใช้ API หาก API เหมาะสมเธออาจจะรู้ว่ามันคืออะไร ทำโดยไม่มีคำนำหน้า

อีกอย่างหนึ่งคือง่ายที่จะเข้าใจว่านี่คือคุณสมบัติเพราะnameไม่ใช่คำกริยา

สถานการณ์ที่เลวร้ายที่สุดหาก API มีความสอดคล้องกันและบุคคลนั้นไม่ทราบว่าname()เป็น accessor และname(value)เป็นผู้กลายพันธุ์เธอจะต้องค้นหาเพียงครั้งเดียวในเอกสารเพื่อทำความเข้าใจกับรูปแบบ

เท่าที่ฉันรัก C # ฉันไม่คิดว่า C ++ ต้องการคุณสมบัติเลย!

ไม่ .. แต่คุณควรพิจารณาว่ามันเป็นเพียงแค่ get: set function และไม่มีงานเพิ่มเติมใด ๆ ที่สร้างไว้แล้วภายใน get: set method เพียงแค่ทำให้เป็นสาธารณะ

ฉันรวบรวมแนวคิดจากแหล่งที่มาของ C ++ หลายแหล่งและนำไปใช้เป็นตัวอย่างที่ดี แต่ค่อนข้างง่ายสำหรับ getters / setters ใน 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;
}

เอาท์พุต:

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

คุณสามารถทดสอบออนไลน์ได้ที่นี่: http://codepad.org/zosxqjTX

คลาสของคุณจำเป็นต้องบังคับใช้สิ่งที่ไม่แปรเปลี่ยนหรือเป็นเพียงการจัดกลุ่มองค์ประกอบเชิงตรรกะของสมาชิก? หากเป็นอย่างหลังคุณควรพิจารณาทำให้สิ่งนั้นเป็นโครงสร้างและเข้าถึงสมาชิกโดยตรง

มีชุดของแมโครที่เขียนอยู่นี่ มีการประกาศคุณสมบัติที่น่าเชื่อถือสำหรับประเภทค่าประเภทอ้างอิงประเภทอ่านอย่างเดียวประเภทที่แข็งแกร่งและอ่อนแอ

class MyClass {

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

 public:
 ...

}