本机 C++ 属性的可移植性

2021-12-22 00:00:00 gcc properties visual-c++ c++ c++11

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

In Visual Studio, there is __declspec(property) which creates properties similar to C#. Borland C++ offers the __property keyword with the exact same functionality. In the C++0x, there is mention of a implicit keyword that could be expanded to implement the same functionality. But it didn't make it into the spec.

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

I am looking for a portable and relatively clean method of declaring syntactically sugared properties that will compile in the latest compilers for Windows, OSX and Linux. I am not concerned with compiler compatibility, just one compiler per platform.

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

I am not looking for alternatives to properties that require parenthesis to get or set the property, such as overloaded methods separating the getters and setters.

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

Here is an ideal usage which compiles in 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++...

This is something similar to what you are asking and is (I hope) standard 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 << "
"; }
    int getX() { std::cout << "reading x_
"; return x_; }

    void setY(const int& y) { y_ = y; std::cout << "y new value is " << y << "
"; }
    int getY() { std::cout << "reading y_
"; 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 << "
";
    int y = foo.y; std::cout << y << "
";
    foo.x = 42; std::cout << "assigned!
";
    x = foo.x; std::cout << x << "
";
    std::cout << "same instance prop/prop assign!
";
    foo.x = foo.y;
    std::cout << "different instances prop/prop assign
";
    foo.x = foo2.x;
    std::cout << "calling a function accepting an int parameter
";
    std::cout << "square(" << foo.x << ") = " <<  square(foo.x) << "
";
    return 0;
}

正如您从 main 中看到的，只要您分配 T 类型的值(此处为 int)或隐式分配，用法是透明的可转换为 T 到属性，只要您在读取时将它们转换回 T 值.

As you can see from main the usage is transparent as long as you are assigning values of type T (here int) or implicitly convertible to T to properties and as long you are converting them back to T values on reading.

但是，如果您将 foo.x 传递给模板函数，则行为会有所不同，因为 foo.x 的类型不是 int> 但是 Property 代替.

Behavior will be different however if you for example pass foo.x to a template function because the type of foo.x is not int but Property<Foo, int, ...> instead.

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

You can also have problems with non-template functions... calling a function accepting a T value will work fine, however a T& parameter is for example going to be a problem because basically the function is asking a variable to access directly using the address. For the same reason you cannot pass of course the address of a property to a function accepting a T* parameter.

相关文章