C ++ 11 có thuộc tính kiểu C # không?

Trong C #, có một đường cú pháp tuyệt vời cho các trường với getter và setter. Hơn nữa, tôi thích các thuộc tính được triển khai tự động cho phép tôi viết

public Foo foo { get; private set; }

Trong C ++ tôi phải viết

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

Có một số khái niệm như vậy trong C ++ 11 cho phép tôi có một số cú pháp về điều này không?

Trong C ++, bạn có thể viết các tính năng của riêng mình. Đây là một ví dụ triển khai các thuộc tính bằng cách sử dụng các lớp không tên. Bài viết trên 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;
};

Bạn có thể viết getters & setters của riêng mình tại chỗ và nếu bạn muốn quyền truy cập thành viên lớp chủ sở hữu, bạn có thể mở rộng mã ví dụ này.

C ++ không tích hợp sẵn tính năng này, bạn có thể xác định một mẫu để bắt chước chức năng thuộc tính:

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

Để xác định một thuộc tính :

Property<float> x;

Để triển khai getter / setter tùy chỉnh, chỉ cần kế thừa:

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;

Để xác định thuộc tính chỉ đọc :

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

Và để sử dụng nó trong lớpOwner :

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

Bạn có thể xác định một số điều trên trong macro để làm cho nó ngắn gọn hơn.

Không có gì trong ngôn ngữ C ++ sẽ hoạt động trên tất cả các nền tảng và trình biên dịch.

Nhưng nếu bạn sẵn sàng phá vỡ khả năng tương thích đa nền tảng và cam kết với một trình biên dịch cụ thể, bạn có thể sử dụng cú pháp như vậy, ví dụ: trong Microsoft Visual C ++, bạn có thể làm

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

Bạn có thể mô phỏng getter và setter ở một mức độ nào đó bằng cách có một thành viên của loại chuyên dụng và ghi đè operator(type)và operator=cho nó. Liệu đó có phải là một ý tưởng hay hay không lại là một câu hỏi khác và tôi sẽ đi đến +1câu trả lời của Kerrek SB để bày tỏ ý kiến ​​của mình về vấn đề đó :)

Có thể hãy xem lớp thuộc tính mà tôi đã tập hợp trong những giờ qua: /codereview/7786/c11-feedback-on-my-approach-to-c-like-class-properties

Nó cho phép bạn có các thuộc tính hoạt động như sau:

CTestClass myClass = CTestClass();

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

Với C ++ 11, bạn có thể xác định mẫu lớp Thuộc tính và sử dụng nó như sau:

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

Và đây là mẫu lớp Thuộc tính.

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

Như nhiều người khác đã nói, không có hỗ trợ tích hợp trong ngôn ngữ. Tuy nhiên, nếu bạn đang nhắm mục tiêu trình biên dịch C ++ của Microsoft, bạn có thể tận dụng tiện ích mở rộng dành riêng cho Microsoft cho các thuộc tính được ghi lại ở đây.

Đây là ví dụ từ trang được liên kết:

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

Không, C ++ không có khái niệm về thuộc tính. Mặc dù có thể hơi khó khăn khi định nghĩa và gọi getThis () hoặc setThat (value), nhưng bạn đang đưa ra một tuyên bố với người tiêu dùng về những phương thức đó rằng một số chức năng có thể xảy ra. Mặt khác, việc truy cập các trường trong C ++ cho người tiêu dùng biết rằng sẽ không có chức năng bổ sung hoặc không mong muốn nào xảy ra. Các thuộc tính sẽ làm cho điều này ít rõ ràng hơn vì truy cập thuộc tính thoạt nhìn có vẻ phản ứng như một trường, nhưng thực tế lại phản ứng như một phương thức.

Ngoài ra, tôi đang làm việc trong một ứng dụng .NET (một CMS rất nổi tiếng) để cố gắng tạo ra một hệ thống thành viên khách hàng. Do cách họ đã sử dụng các thuộc tính cho các đối tượng người dùng của họ, các hành động đã xảy ra mà tôi không lường trước được, khiến các triển khai của tôi thực thi theo những cách kỳ lạ bao gồm cả đệ quy vô hạn. Điều này là do các đối tượng người dùng của họ đã thực hiện lệnh gọi đến lớp truy cập dữ liệu hoặc một số hệ thống bộ nhớ đệm toàn cầu khi cố gắng truy cập những thứ đơn giản như StreetAddress. Toàn bộ hệ thống của họ được thành lập dựa trên cái mà tôi gọi là lạm dụng tài sản. Nếu họ đã sử dụng các phương thức thay vì thuộc tính, tôi nghĩ rằng tôi sẽ nhận ra điều gì đang xảy ra nhanh hơn nhiều. Nếu họ đã sử dụng các trường (hoặc ít nhất là làm cho các thuộc tính của họ hoạt động giống các trường hơn), tôi nghĩ rằng hệ thống sẽ dễ dàng mở rộng và bảo trì hơn.

[Chỉnh sửa] Đã thay đổi suy nghĩ của tôi. Tôi đã có một ngày tồi tệ và hơi thất vọng. Việc dọn dẹp này nên chuyên nghiệp hơn.

Dựa trên https://stackoverflow.com/a/23109533/404734, đây là phiên bản có bộ cài công khai và bộ cài đặt riêng:

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

Đây không chính xác là một thuộc tính, nhưng nó thực hiện những gì bạn muốn theo cách đơn giản:

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

Ở đây, dấu X lớn hoạt động giống như public int X { get; private set; }trong cú pháp C #. Nếu bạn muốn các thuộc tính toàn diện, tôi đã thực hiện lần đầu tiên để triển khai chúng ở đây .

Bạn có thể biết điều đó nhưng tôi chỉ đơn giản làm như sau:

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

Cách tiếp cận này rất đơn giản, không sử dụng thủ thuật thông minh và nó sẽ hoàn thành công việc!

Mặc dù vậy, vấn đề là một số người không thích đánh dấu gạch dưới trước các trường riêng tư của họ và vì vậy họ không thể thực sự sử dụng cách tiếp cận này, nhưng may mắn thay cho những người này, nó thực sự đơn giản. :)

Các tiền tố get và set không thêm rõ ràng cho API của bạn nhưng làm cho chúng dài dòng hơn và lý do tôi không nghĩ rằng họ thêm thông tin hữu ích là vì khi ai đó cần sử dụng một API nếu API có ý nghĩa thì cô ấy có thể sẽ nhận ra nó là gì không có tiền tố.

Một điều nữa, thật dễ hiểu rằng đây là những thuộc tính vì namekhông phải là một động từ.

Trường hợp xấu nhất, nếu các API nhất quán và người đó không nhận ra đó name()là trình truy cập và name(value)là kẻ đột biến thì cô ấy sẽ chỉ phải tra cứu nó một lần trong tài liệu để hiểu mẫu.

Tôi yêu C # nhiều như vậy, tôi không nghĩ C ++ cần thuộc tính gì cả!

Không .. Nhưng bạn nên cân nhắc nếu nó chỉ là hàm get: set và không có tác vụ bổ sung nào được định dạng sẵn bên trong các phương thức get: set chỉ đặt nó ở chế độ công khai.

Tôi đã thu thập các ý tưởng từ nhiều nguồn C ++ và đưa nó vào một ví dụ đẹp, vẫn khá đơn giản cho getters / setters trong 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;
}

Đầu ra:

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

Bạn có thể kiểm tra trực tuyến tại đây: http://codepad.org/zosxqjTX

Lớp bạn có thực sự cần thực thi một số bất biến hay chỉ là một nhóm hợp lý của các phần tử thành viên? Nếu đó là cái thứ hai, bạn nên cân nhắc việc tạo một cấu trúc và truy cập trực tiếp vào các thành viên.

Có một tập hợp các macro được viết ở đây . Nó có các khai báo thuộc tính thuận lợi cho các loại giá trị, loại tham chiếu, loại chỉ đọc, loại mạnh và yếu.

class MyClass {

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

 public:
 ...

}