带有引用成员的赋值运算符

发布于 2024-12-11 18:59:38 字数 466 浏览 0 评论 0原文

这是使用引用成员创建赋值运算符的有效方法吗？

#include <new>

struct A
{
    int &ref;
    A(int &Ref) : ref(Ref) { }
    A(const A &second) : ref(second.ref) { }
    A &operator =(const A &second)
    {
        if(this == &second)
            return *this;
        this->~A();
        new(this) A(second);
        return *this;
    }
}

它似乎编译和运行得很好，但是由于 C++ 倾向于在最意想不到的时候表现出未定义的行为，而且所有的人都说这是不可能的，我认为我错过了一些陷阱。我错过了什么吗？

原文

Is this a valid way to create an assignment operator with members that are references?

#include <new>

struct A
{
    int &ref;
    A(int &Ref) : ref(Ref) { }
    A(const A &second) : ref(second.ref) { }
    A &operator =(const A &second)
    {
        if(this == &second)
            return *this;
        this->~A();
        new(this) A(second);
        return *this;
    }
}

It seems to compile and run fine, but with c++ tendency to surface undefined behavior when least expected, and all the people that say its impossible, I think there is some gotcha I missed. Did I miss anything?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

吃素的狼 2024-12-18 18:59:38

它在语法上是正确的。但是，如果新的展示位置抛出异常，您
最终得到一个你无法破坏的物体。更不用说灾难了
如果有人来自你的班级。只是不要这样做。

解决方案很简单：如果类需要支持作业，则不要
使用任何参考成员。我有很多课程可供参考
参数，但将它们存储为指针，以便类可以支持
任务。像这样的东西：

struct A
{
    int* myRef;
    A( int& ref ) : myRef( &ref ) {}
    // ...
};

It's syntactically correct. If the placement new throws, however, you
end up with an object you can't destruct. Not to mention the disaster
if someone derives from your class. Just don't do it.

The solution is simple: if the class needs to support assignment, don't
use any reference members. I have a lot of classes which take reference
arguments, but store them as pointers, just so the class can support
assignment. Something like:

struct A
{
    int* myRef;
    A( int& ref ) : myRef( &ref ) {}
    // ...
};

回复收藏 0 原文

小伙你站住 2024-12-18 18:59:38

另一个解决方案是使用reference_wrapper类（在功能标头中）：

struct A
{
    A(int& a) : a_(a) {}
    A(const A& a) : a_(a.a_) {}

    A& operator=(const A& a)
    {
        a_ = a.a_;
        return *this;
    }

    void inc() const
    {
        ++a_;
    }

    std::reference_wrapper<int>a_;

};

Another solution is to use the reference_wrapper class ( in functional header ) :

struct A
{
    A(int& a) : a_(a) {}
    A(const A& a) : a_(a.a_) {}

    A& operator=(const A& a)
    {
        a_ = a.a_;
        return *this;
    }

    void inc() const
    {
        ++a_;
    }

    std::reference_wrapper<int>a_;

};

回复收藏 0 原文