Есть ли у C ++ 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; }
};

Вы можете определить некоторые из вышеперечисленных макросов, чтобы сделать его более кратким.

В языке 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;  
}

Вы можете до некоторой степени эмулировать геттер и сеттер, имея член выделенного типа и переопределяя 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; }
};

А вот и шаблон класса 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;
};

Как уже говорили многие, в языке нет встроенной поддержки. Однако, если вы ориентируетесь на компилятор 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. Вся их система была основана на том, что я бы назвал злоупотреблением собственностью. Если бы они использовали методы вместо свойств, думаю, я бы гораздо быстрее понял, что пошло не так. Если бы они использовали поля (или, по крайней мере, сделали бы их свойства более похожими на поля), я думаю, что систему было бы легче расширять и поддерживать.

[Edit] Изменил свои мысли. У меня был плохой день, и я немного рассердился. Эта очистка должна быть более профессиональной.

На основе 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 ++ вообще нуждается в свойствах!

Нет ... Но вы должны подумать, если это просто функция get: set и никакие дополнительные задачи не выполняются внутри методов get: set, просто сделайте ее общедоступной.

Я собрал идеи из нескольких источников 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:
 ...

}