Наличие открытых свойств в классе c ++ - PullRequest
Новая
       5

Наличие открытых свойств в классе c ++

12 голосов
/ 01 апреля 2010

Как у меня есть свойства в классе C ++, как у вас в классе C #.

Я не хочу использовать методы получения и установки.

Ответы [ 7 ]

12 голосов
/ 01 апреля 2010

Вы можете использовать решение, аналогичное предложенному Джоном, но сохраняя обычную семантику C ++ с использованием перегрузки операторов. Я слегка изменил код Джона следующим образом (объяснения следуют за кодом): 

#include <iostream>

template<typename T>
class Accessor {
public:
    explicit Accessor(const T& data) : value(data) {}

    Accessor& operator=(const T& data) { value = data; return *this; }
    Accessor& operator=(const Accessor& other) { this->value = other.value; return *this; }
    operator T() const { return value; }
    operator T&() { return value; }

private:
    Accessor(const Accessor&);


    T value;

};

struct Point {
    Point(int a = 0, int b = 0) : x(a), y(b) {}
    Accessor<int> x;
    Accessor<int> y;
};

int main() {
    Point p;
    p.x = 10;
    p.y = 20;
    p.x++;
    std::cout << p.x << "," << p.y << std::endl;

    p.x = p.y = 15;
    std::cout << p.x << "," << p.y << std::endl;

    return 0;
}

Мы перегружаем operator=, чтобы сохранить обычный синтаксис присваивания вместо синтаксиса, похожего на вызов функции. Мы используем оператор приведения в качестве «добытчика». Нам нужна вторая версия operator=, чтобы разрешить присваивание второго вида в main().

Теперь вы можете добавить к указателям на функции конструктора Accessor или, что еще лучше, к функторам - вызывать их как методы получения / установки любым способом, который вам подходит. В следующем примере предполагается, что функция setter возвращает bool, чтобы передать согласие на установку нового значения, а getter может просто изменить его при выходе: 

#include <iostream>
#include <functional>
#include <cmath>

template<typename T>
class MySetter {
public:
    bool operator()(const T& data)
    {
        return (data <= 20 ? true : false);
    }
};

template<typename T>
class MyGetter {
public:
    T operator()(const T& data)
    {
        return round(data, 2);
    }

private:
    double cint(double x) {
        double dummy;
        if (modf(x,&dummy) >= 0.5) {
            return (x >= 0 ? ceil(x) : floor(x));
        } else {
            return (x < 0 ? ceil(x) : floor(x));
        }
    }

    double round(double r, int places) {
        double off = pow(10.0L, places);
        return cint(r*off)/off;
    }
};

template<typename T, typename G = MyGetter<T>, typename S = MySetter<T>>
class Accessor {
public:
    explicit Accessor(const T& data, const G& g = G(), const S& s = S()) : value(data), getter(g), setter(s) {}

    Accessor& operator=(const T& data) { if (setter(data)) value = data; return *this; }
    Accessor& operator=(const Accessor& other) { if (setter(other.value)) this->value = other.value; return *this; }
    operator T() const { value = getter(value); return value;}
    operator T&() { value = getter(value); return value; }

private:
    Accessor(const Accessor&);

    T value;

    G getter;
    S setter;

};

struct Point {
    Point(double a = 0, double b = 0) : x(a), y(b) {}
    Accessor<double> x;
    Accessor<double> y;
};

int main() {
    Point p;
    p.x = 10.712;
    p.y = 20.3456;
    p.x+=1;
    std::cout << p.x << "," << p.y << std::endl;

    p.x = p.y = 15.6426;
    std::cout << p.x << "," << p.y << std::endl;

    p.x = p.y = 25.85426;
    std::cout << p.x << "," << p.y << std::endl;

    p.x = p.y = 19.8425;
    p.y+=1;
    std::cout << p.x << "," << p.y << std::endl;

    return 0;
}

Однако, как показывает последняя строка, в ней есть ошибка. Оператор приведения, возвращающий T &, позволяет пользователям обходить установщик, поскольку он дает им доступ к частному значению. Один из способов устранения этой ошибки - реализовать все операторы, которые вы хотите предоставить вашему Accessor. Например, в следующем коде я использовал оператор + =, и поскольку я удалил оператор приведения, возвращающий ссылку, мне пришлось реализовать operator+=: 

#include <iostream>
#include <functional>
#include <cmath>

template<typename T>
class MySetter {
public:
    bool operator()(const T& data) const {
        return (data <= 20 ? true : false);
    }
};

template<typename T>
class MyGetter {
public:
    T operator() (const T& data) const {
        return round(data, 2);
    }

private:
    double cint(double x) const {
        double dummy;
        if (modf(x,&dummy) >= 0.5) {
            return (x >= 0 ? ceil(x) : floor(x));
        } else {
            return (x < 0 ? ceil(x) : floor(x));
        }
    }

    double round(double r, int places) const {
        double off = pow(10.0L, places);
        return cint(r*off)/off;
    }
};

template<typename T, typename G = MyGetter<T>, typename S = MySetter<T>>
class Accessor {
private:
public:
    explicit Accessor(const T& data, const G& g = G(), const S& s = S()) : value(data), getter(g), setter(s) {}

    Accessor& operator=(const T& data) { if (setter(data)) value = data; return *this; }
    Accessor& operator=(const Accessor& other) { if (setter(other.value)) this->value = other.value; return *this; }
    operator T() const { return getter(value);}

    Accessor& operator+=(const T& data) { if (setter(value+data)) value += data; return *this; }

private:
    Accessor(const Accessor&);

    T value;

    G getter;
    S setter;

};

struct Point {
    Point(double a = 0, double b = 0) : x(a), y(b) {}
    Accessor<double> x;
    Accessor<double> y;
};

int main() {
    Point p;
    p.x = 10.712;
    p.y = 20.3456;
    p.x+=1;
    std::cout << p.x << "," << p.y << std::endl;

    p.x = p.y = 15.6426;
    std::cout << p.x << "," << p.y << std::endl;

    p.x = p.y = 25.85426;
    std::cout << p.x << "," << p.y << std::endl;

    p.x = p.y = 19.8425;
    p.y+=1;
    std::cout << p.x << "," << p.y << std::endl;

    return 0;
}

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

7 голосов
/ 01 апреля 2010

Для такого поведения я использую шаблонный мета-аксессор. Вот очень упрощенный для типов POD: 

template<class T>
struct accessor {

    explicit accessor(const T& data) : value(data) {}
    T operator()() const { return value; }
    T& operator()() { return value; }
    void operator()(const T& data) { value = data; }

private:

    accessor(const accessor&);
    accessor& operator=(const accessor&);
    T value;

};

Типичное использование выглядит так: 

struct point {
    point(int a = 0, int b = 0) : x(a), y(b) {}
    accessor<int> x;
    accessor<int> y;
};

point p;
p.x(10);
p.y(20);
p.x()++;
std::cout << p.x();

Компилятор обычно вставляет эти вызовы, если вы настроили все правильно и включили оптимизацию. Это не более узкое место в производительности, чем использование реальных методов получения и установки независимо от того, какие оптимизации происходят. Тривиально расширить это, чтобы автоматически поддерживать не POD или перечислимые типы, или позволить регистрировать обратные вызовы при каждом чтении или записи данных.

Редактировать : Если вы предпочитаете не использовать скобки, вы всегда можете определить operator=() и неявный оператор приведения. Вот версия, которая делает именно это, в то же время добавляя базовую поддержку обратного вызова «все произошло»:

Дальнейшее редактирование : Хорошо, совершенно не хватало того, что кто-то уже сделал пересмотренную версию моего кода. Вздох.

3 голосов
/ 02 апреля 2010

Если вам все равно, что ваш код C ++ не будет компилироваться ни с чем, кроме компилятора Microsoft Visual C ++, вы можете использовать некоторые нестандартные расширения компилятора.

Например, следующий код создаст C # -подобное свойство с именем MyProperty. 

struct MyType
{
    // This function pair may be private (for clean encapsulation)
    int get_number() const { return m_number; }
    void set_number(int number) { m_number = number; }

    __declspec(property(get=get_number, put=set_number)) int MyProperty;
private:
    int m_number:
}

int main()
{
    MyType m;
    m.MyProperty = 100;
    return m.MyProperty;
}

Более подробная информация об этом специфическом для Microsoft расширении языка доступна здесь .

3 голосов
/ 01 апреля 2010

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

http://www.codef00.com/code/Property.h

Вот пример использования: 

#include <iostream>
#include "Property.h"


class TestClass {
public:
    // make sure to initialize the properties with pointers to the object
    // which owns the property
    TestClass() : m_Prop1(0), m_Prop3(0.5), prop1(this), prop2(this), prop3(this) {
    }

private:
    int getProp1() const {
        return m_Prop1;
    }

    void setProp1(int value) {
        m_Prop1 = value;
    }

    int getProp2() const {
        return 1234;
    }

    void setProp3(double value) {
        m_Prop3 = value;
    }

    int m_Prop1;
    double m_Prop3;

public:
    PropertyRW<int, TestClass, &TestClass::getProp1, &TestClass::setProp1> prop1;
    PropertyRO<int, TestClass, &TestClass::getProp2> prop2;
    PropertyWO<double, TestClass, &TestClass::setProp3> prop3;
};

и некоторое использование этого класса ... 

int main() {
    unsigned int a;
    TestClass t;
    t.prop1 = 10;
    a = t.prop1;
    t.prop3 = 5;
    a = t.prop2;
    std::cout << a << std::endl;
    return 0;
}

При таком подходе есть две неприятности:

  1. Вы должны дать собственности указатель на собственный класс.
  2. Синтаксис объявления свойства является немного многословно, но держу пари, я могу очистить это немного с некоторыми макросами
1 голос
/ 01 апреля 2010

Вы можете предоставить методы get и set, имена которых похожи на элементы данных: 

class Example
{
  private:
     unsigned int x_;
     double d_;
     std::string s_s;
  public:
     unsigned int x(void) const
     { return x_;}

     void x(unsigned int new_value)
     { x_ = new_value;}

     double d(void) const
     { return d_;}
     void d(double new_value)
     { d_ = new_value;}

     const std::string& s(void) const
     { return s_;}
     void s(const std::string& new_value)
     { s_ = new_value;}
};

Хотя это и близко, поскольку для каждого члена требуется использование '()', оно не соответствует точным функциям свойств , которые предоставляют Языки Microsoft.

Самое близкое соответствие для свойств - объявить элементы данных как общедоступные.

1 голос
/ 01 апреля 2010

Свойства не поддерживаются в C ++, но вы можете реализовать их:
1) Используя шаблоны
2) Путем расширения языка и написания собственного кода препроцессора

Любой подход не будет легким, но это может быть сделано.

1 голос
/ 01 апреля 2010

Ты не. C ++ не поддерживает свойства, как в C #. Если вы хотите, чтобы код запускался на set / get, это должен быть метод.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.

Нет похожих вопросов

...