Чи має С ++ 11 властивості стилю C #?

У C # є симпатичний синтаксичний цукор для полів з геттером та сеттером. Більше того, мені подобаються автореалізовані властивості, які дозволяють мені писати

public Foo foo { get; private set; }

У C ++ я повинен писати

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

Чи є така концепція в C ++ 11, яка дозволяє мені мати синтаксичний цукор на цьому?

У C ++ ви можете писати власні функції. Ось приклад реалізації властивостей за допомогою неназваних класів. Стаття у Вікіпедії

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

Ви можете написати свої власні геттери та сетери, і якщо ви хочете отримати доступ до учасника класу, ви можете розширити цей приклад коду.

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

Для реалізації користувацького геттера / сеттера просто успадкуйте:

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

Ви можете визначити щось із зазначеного в макросах, щоб зробити його більш стислим.

У мові С ++ немає нічого, що працювало б на всіх платформах та компіляторах.

Але якщо ви готові порушити крос-платформну сумісність і прив'язатись до певного компілятора, ви можете скористатися таким синтаксисом, наприклад, у 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перейду до відповіді Керрека С.Б., щоб висловити свою думку щодо цього :)

Можливо, подивіться на клас властивостей, який я зібрав за останні години: /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);

За допомогою C ++ 11 ви можете визначити шаблон класу Property та використовувати його так:

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

Як і багато інших вже говорили, вбудованої підтримки в мові немає. Однак, якщо ви націлені на компілятор 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 ось версія із загальнодоступним геттером та приватним сеттером:

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

Цей підхід простий, не використовує хитромудрих хитрощів, і це робить роботу!

Проблема полягає в тому, що деякі люди не люблять префіксувати свої приватні поля підкресленням, тому вони не можуть насправді використовувати цей підхід, але на щастя для тих, хто це робить, це насправді просто. :)

Префікси get і set не додають ясності вашому API, але роблять їх більш детальними, і тому я не думаю, що вони додають корисну інформацію, тому що коли комусь потрібно використовувати API, якщо API має сенс, вона, мабуть, зрозуміє, що це обходиться без префіксів.

Ще одне, легко зрозуміти, що це властивості, оскільки nameце не дієслово.

Найгірший сценарій, якщо API-интерфейси узгоджуються, і людина не усвідомлює, що name()це аксесуар і name(value)є мутатором, то їй потрібно буде лише один раз шукати це в документації, щоб зрозуміти шаблон.

Як би я не любив C #, я не думаю, що C ++ взагалі потребує властивостей!

Ні .. Але слід врахувати, чи просто це: функція set і не додаткове завдання, попередньо сформоване всередині get: встановлені методи просто оприлюднюють її.

Я зібрав ідеї з кількох джерел на C ++ і вклав їх у приємний, все ще досить простий приклад для геттерів / сеттерів у 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:
 ...

}