我在使用无法更改的第 3 方代码时发现问题。我需要复制对象成员。我不能严格执行此操作，因为其中一个内部成员具有私有(private)赋值运算符。我找到的唯一解决方案是棘手的，所以我想问你是否看到任何可能影响我的程序的红灯。

这是我正在处理的简化代码(记住我无法更改它!):

#include 
#include 

class MBool
{
công cộng:
    MBool() {};
    MBool(const MBool& arg) {}
riêng tư:    
    MBool& operator=(const MBool& arg);
};

class InnerContent {
riêng tư:
    int* pBuffer;

công cộng: 
    InnerContent() {
        pBuffer = new int[20];
        std::cout << "InnerContent()" << std::endl;
    }

    InnerContent(const InnerContent& otherInnerContent) {
        pBuffer = new int[20];
        std::copy(otherInnerContent.pBuffer, otherInnerContent.pBuffer + 20, pBuffer);
        std::cout << "InnerContent(const InnerContent&)" << std::endl;
    }

    ~InnerContent() {
        std::cout << "~InnerContent()" << std::endl;
        delete [] pBuffer;
        pBuffer = nullptr;
    }

    virtual void someVirtualFunction() {}
};

class Content {
công cộng:
    InnerContent innerContent;
    int someNumber;
    MBool boolVar;

    Content() {
        std::cout << "Content()" << std::endl;
    }
    ~Content() {
        std::cout << "~Content()" << std::endl;
    }
    Content(const Content& otherContent) :
        innerContent(otherContent.innerContent),
        someNumber(otherContent.someNumber),
        boolVar(otherContent.boolVar)
    {
        std::cout << "Content(const Content&)" << std::endl;
    }

    virtual void someVirtualFunction() {}
};

class A {
công cộng: 
    Content content;

    A() { std::cout << "A()" << std::endl; }
    ~A() { std::cout << "~A()" << std::endl; }
};

class B {
công cộng: 
    Content content;

    B() { std::cout << "B()" << std::endl; }
    ~B() { std::cout << "~B()" << std::endl; }
};

这就是我要用它做的事情(只有这段代码可以修改和扩展):

void copyContent(Content& contentFrom, Content& contentTo) {
    contentTo.~Content();
    new (&contentTo) Content(contentFrom);
};

int chính() {
    Một là;
    B b;

    // I wish to do this:
    //b.content = a.content;
    // but Content class has no operator= function implemented
    // also I can't use generated assignment operator function because of MBool::operator= is private

    // The only work-around I found is this:

    std::cout << "--- Before copying" << std::endl;
    copyContent(a.content, b.content);
    std::cout << "--- After copying" << std::endl;
}

我的解决方案是手动调用 Content 析构函数以释放 Content 及其内部类中任何动态分配的内存。堆栈上的内存保持不变，因此我可以通过 placement-new 运算符重用它，该运算符调用存在的复制构造函数并完全满足我的需要。当主函数范围结束时，“a”对象被正确清理。

代码输出:

InnerContent()
Content()
A()
InnerContent()
Content()
B()
--- Before copying
~Content()
~InnerContent()
InnerContent(const InnerContent&)
Content(const Content&)
--- After copying
~B()
~Content()
~InnerContent()
~A()
~Content()
~InnerContent()

我不想创建自己的函数来复制所有字段，因为此类可以在新版本中更新，并且可能有其他字段我不会复制，很可能没有人会记得修复它。

câu hỏi:您认为这会导致任何内存泄漏或内存损坏吗？你看到我没有提到的任何问题吗？

câu trả lời hay nhất

基本上这个想法应该可行。为了保护自己不至于忘记调用析构函数，我认为，您应该将整个想法包装在一种类似于类模板的智能指针中。在此示例中，它实际上并没有包装指针，而是包装了内容对象本身。

template 
class content_wrapper {
    riêng tư:
        ContentType content_;
    công cộng:
        content_wrapper() : content_ {} {};
        content_wrapper(const content_wrapper& other) :
            content_{other.content_} {};

        content_wrapper& operator = (const content_wrapper& other) {
            content_.~ContentType();
            new (&content_) ContentType(other);
            return *this;
        }

        ContentWrapper& operator * () {
            return content_;
        }
        ContentWrapper* operator -> () {
            return &content_;
        }
};

现在你可以像这样使用它了:

class A {
    công cộng: 
        content_wrapper content;

        A() { std::cout << "A()" << std::endl; }
        ~A() { std::cout << "~A()" << std::endl; }
};

class B {
    công cộng: 
        content_wrapper content;

        B() { std::cout << "B()" << std::endl; }
        ~B() { std::cout << "~B()" << std::endl; }
};

int chính() {
    Một là;
    B b;

    b.content = a.content; // the wrapper will take care.

    b.content->someVirtualFunction();
}

易于阅读，无论何时您想要分配内容对象，您都永远不会忘记析构函数调用。

关于c++ - 使用 placement-new 运算符和复制构造函数代替赋值运算符，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39351776/