0

我正在研究五法则及其表亲（四法则和 1/2、复制和交换成语、朋友交换功能）。

我在测试课上实施了四和 1/2 规则。它编译得很好。我的实施中是否有任何隐藏的错误？

我特别关注存储在我在复制构造函数中移动的m_unorederd_map属性中的 unique_ptrs，因为它们无法被复制。这是在类中处理 unique_ptrs 的正确方法吗？

某个类.h

#ifndef SOMECLASS_H
#define SOMECLASS_H

#include "someotherclass.h"

#include <QString>
#include <QStringList>

#include <memory>
#include <string>
#include <unordered_map>

class SomeClass
{
    QString m_qstring;
    std::unordered_map<std::string, std::unique_ptr<SomeOtherClass>> m_unordered_map;
    int m_int;
    std::string m_string;
    QStringList m_qstringlist;

public:
    SomeClass() = default;

    // Rule of 5 (or Rule of 4 and 1/2)
    // From https://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom#3279550
    ~SomeClass() = default;                               // Destructor
    SomeClass(SomeClass &other);                          // Copy constructor
    SomeClass(SomeClass &&other);                         // Move constructor
    SomeClass &operator=(SomeClass other);                // Copy/Move assignment operator
    friend void swap(SomeClass &first, SomeClass &second) // Friend swap function
    {
        using std::swap;
        first.m_qstring.swap(second.m_qstring);
        first.m_unordered_map.swap(second.m_unordered_map);
        swap(first.m_int, second.m_int);
        swap(first.m_string, second.m_string);
        first.m_qstringlist.swap(second.m_qstringlist);
    }
};

#endif // SOMECLASS_H

某类.cpp

#include "someclass.h"

// Copy constructor
SomeClass::SomeClass(SomeClass &other)
    : m_qstring(other.m_qstring),
      m_int(other.m_int),
      m_string(other.m_string),
      m_qstringlist(other.m_qstringlist)
{
    // m_unordered_map holds unique_ptrs which can't be copied.
    // So we move it.
    m_unordered_map = std::move(other.m_unordered_map);
}

// Move constructor
SomeClass::SomeClass(SomeClass &&other)
    : SomeClass()
{
    swap(*this, other);
}

// Copy/Move assignment operator
SomeClass &SomeClass::operator=(SomeClass other)
{
    swap(*this, other);
    return *this;
}
4

1 回答 1

6

最重要的是：

  • 此类不需要自定义复制/移动操作，也不需要析构函数，因此应遵循 0 规则。

其他事情：

  • 我不喜欢swap(*this, other);搬家。它强制成员默认构造，然后分配。一个更好的选择是使用成员初始化列表，带有std::exchange.

    如果初始化所有成员变得乏味，请将它们包装在一个结构中。它也使写作swap变得更容易。

  • 复制构造函数必须通过 const 引用获取参数。

  • unique_ptrs which can't be copied. So we move it.是一个不好的理由。如果您的成员无法复制，请不要定义复制操作。存在自定义移动操作时，不会自动生成复制操作

  • 移动操作（包括按值赋值）应该是noexcept，因为标准容器在某些情况下不会使用它们。

  • SomeClass() = default;导致通常未初始化的成员 ( int m_int;) 有时会归零，具体取决于类的构造方式。（例如SomeClass x{};将其归零，但SomeClass x;不会。）

    除非您想要这种行为，否则构造函数应替换为SomeClass() {}，并且m_int可能应归零（在类主体中）。

于 2022-01-29T18:41:47.320 回答