在 Visual Studio 中，有 __declspec(property)它创建类似于 C# 的属性。 Borland C++ 提供了具有完全相同功能的 __property 关键字。在 C++0x 中，提到了 implicit可以扩展以实现相同功能的关键字。但它没有进入规范。

我正在寻找一种可移植且相对干净的方法来声明语法糖化属性，该方法将在适用于 Windows、OSX 和 Linux 的最新编译器中编译。我不关心编译器的兼容性，每个平台只有一个编译器。

我不是在寻找需要括号来获取或设置属性的属性的替代方法，例如分隔 getter 和 setter 的重载方法。

这是在 Visual Studio 2010 中编译的理想用法:

#define _property(_type, _name, _get, _put) __declspec(property(get=_get, put=_put)) _type _name
#define _property_readonly(_type, _name, _get) __declspec(property(get=_get)) _type _name

class Window
{
public:
    _property_readonly(void*, Handle, GetHandle);
    _property(bool, Visible, GetVisible, SetVisible);

    void* GetHandle();
    bool GetVisible();
    void SetVisible(bool);
}

void main()
{
    Window MainWindow;
    if (!MainWindow.Visible)
        MainWindow.Visible = true;
}

最佳答案

这与您所要求的类似，并且是(我希望)标准 C++...

#include <iostream>

template<typename C, typename T, T (C::*getter)(), void (C::*setter)(const T&)>
struct Property
{
    C *instance;

    Property(C *instance)
        : instance(instance)
    {
    }

    operator T () const
    {
        return (instance->*getter)();
    }

    Property& operator=(const T& value)
    {
        (instance->*setter)(value);
        return *this;
    }

    template<typename C2, typename T2,
             T2 (C2::*getter2)(), void (C2::*setter2)(const T2&)>
    Property& operator=(const Property<C2, T2, getter2, setter2>& other)
    {
        return *this = (other.instance->*getter2)();
    }

    Property& operator=(const Property& other)
    {
        return *this = (other.instance->*getter)();
    }
};

//////////////////////////////////////////////////////////////////////////

struct Foo
{
    int x_, y_;

    void setX(const int& x) { x_ = x; std::cout << "x new value is " << x << "\n"; }
    int getX() { std::cout << "reading x_\n"; return x_; }

    void setY(const int& y) { y_ = y; std::cout << "y new value is " << y << "\n"; }
    int getY() { std::cout << "reading y_\n"; return y_; }

    Property<Foo, int, &Foo::getX, &Foo::setX> x;
    Property<Foo, int, &Foo::getY, &Foo::setY> y;

    Foo(int x0, int y0)
        : x_(x0), y_(y0), x(this), y(this)
    {
    }
};

int square(int x)
{
    return x*x;
}

int main(int argc, const char *argv[])
{
    Foo foo(10, 20);
    Foo foo2(100, 200);
    int x = foo.x; std::cout << x << "\n";
    int y = foo.y; std::cout << y << "\n";
    foo.x = 42; std::cout << "assigned!\n";
    x = foo.x; std::cout << x << "\n";
    std::cout << "same instance prop/prop assign!\n";
    foo.x = foo.y;
    std::cout << "different instances prop/prop assign\n";
    foo.x = foo2.x;
    std::cout << "calling a function accepting an int parameter\n";
    std::cout << "square(" << foo.x << ") = " <<  square(foo.x) << "\n";
    return 0;
}

正如您在 main 中看到的那样只要您分配类型为 T 的值，用法就是透明的(此处为 int )或隐式转换为 T到属性，只要您将它们转换回 T阅读值(value)观。

但是，如果您通过 foo.x，则行为会有所不同。到模板函数，因为 foo.x 的类型不是 int但是 Property<Foo, int, ...>而是。

您也可能在使用非模板函数时遇到问题...调用接受 T 的函数value 可以正常工作，但是 T&例如，参数将成为一个问题，因为基本上该函数要求变量直接使用地址访问。出于同样的原因，您当然不能将属性的地址传递给接受 T* 的函数。参数。

关于c++ - native C++ 属性的可移植性，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5772480/