Question

让我们看一个简单的例子：

struct some_struct {
   std::string str;
   int a, b, c;
}

some_struct abc, abc_copy;
abc.str = "some text";
abc.a = 1;
abc.b = 2;
abc.c = 3;

abc_copy = abc;

然后abc_copy是abc的完全副本 ..如何没有定义 =运算符？

（在处理一些代码时，这让我感到意外。）

Answer 1

如果你没有定义这四种方法（C ++ 11中有六种），编译器会为你生成它们：

默认构造函数
复制构造函数
作业运营商
析构
移动构造函数（C ++ 11）
移动分配（C ++ 11）

如果你想知道为什么？
它是为了保持与C的向后兼容性（因为C结构可以使用=和声明来复制）。但它也使得编写简单的类更容易。有人会争辩说，由于“浅拷贝问题”，它会增加问题。我反对的论点是你不应该有一个拥有RAW指针的类。通过使用适当的智能指针，问题就会消失。

默认构造函数（如果未定义其他构造函数）

编译器生成的默认构造函数将调用基类的默认构造函数，然后每个成员默认构造函数（按它们声明的顺序）

析构函数（如果没有定义析构函数）

以声明的相反顺序调用每个成员的析构函数。然后调用基类的析构函数。

复制构造函数（如果未定义复制构造函数）

调用传递src对象的基类复制构造函数。然后使用src对象成员调用每个成员的复制构造函数作为要复制的值。

分配操作员

调用传递src对象的基类赋值运算符。然后使用src对象作为要复制的值调用每个成员上的赋值运算符。

移动构造函数（如果未定义移动构造函数）

调用传递src对象的基类移动构造函数。然后使用src对象成员调用每个成员的move构造函数作为要移动的值。

移动分配操作员

调用传递src对象的基类移动赋值运算符。然后使用src对象作为要复制的值来调用每个成员上的move赋值运算符。

如果您定义这样的类：

struct some_struct: public some_base
{   
    std::string str1;
    int a;
    float b;
    char* c;
    std::string str2;
};

编译器将构建的是：

struct some_struct: public some_base
{   
    std::string str1;
    int a;
    float b;
    char* c;
    std::string str2;

    // Conceptually two different versions of the default constructor are built
    // One is for value-initialization the other for zero-initialization
    // The one used depends on how the object is declared.
    //        some_struct* a = new some_struct;     // value-initialized
    //        some_struct* b = new some_struct();   // zero-initialized
    //        some_struct  c;                       // value-initialized
    //        some_struct  d = some_struct();       // zero-initialized
    // Note: Just because there are conceptually two constructors does not mean
    //       there are actually two built.

    // value-initialize version
    some_struct()
        : some_base()            // value-initialize base (if compiler generated)
        , str1()                 // has a normal constructor so just call it
        // PODS not initialized
        , str2()
   {}

    // zero-initialize version
    some_struct()
        : some_base()            // zero-initialize base (if compiler generated)
        , str1()                 // has a normal constructor so just call it.
        , a(0)
        , b(0)
        , c(0)   // 0 is NULL
        , str2()
        // Initialize all padding to zero
   {}

    some_struct(some_struct const& copy)
        : some_base(copy)
        , str1(copy.str1)
        , a(copy.a)
        , b(copy.b)
        , c(copy.c)
        , str2(copy.str2)
    {}

    some_struct& operator=(some_struct const& copy)
    {
        some_base::operator=(copy);
        str1 = copy.str1;
        a    = copy.a;
        b    = copy.b;
        c    = copy.c;
        str2 = copy.str2;
        return *this;
    }

    ~some_struct()
    {}
    // Note the below is pseudo code
    // Also note member destruction happens after user code.
    // In the compiler generated version the user code is empty
        : ~str2()
        // PODs don't have destructor
        , ~str1()
        , ~some_base();
    // End of destructor here.

    // In C++11 we also have Move constructor and move assignment.
    some_struct(some_struct&& copy)
                    //    ^^^^  Notice the double &&
        : some_base(std::move(copy))
        , str1(std::move(copy.str1))
        , a(std::move(copy.a))
        , b(std::move(copy.b))
        , c(std::move(copy.c))
        , str2(std::move(copy.str2))
    {}

    some_struct& operator=(some_struct&& copy)
                               //    ^^^^  Notice the double &&
    {
        some_base::operator=(std::move(copy));
        str1 = std::move(copy.str1);
        a    = std::move(copy.a);
        b    = std::move(copy.b);
        c    = std::move(copy.c);
        str2 = std::move(copy.str2);
        return *this;
    } 
};

Answer 2

在C ++中，结构体等同于成员默认为公共而非私有访问的类。

如果没有提供，C ++编译器也会自动生成类的以下特殊成员：

默认构造函数 - 没有参数，默认初始化所有内容。
复制构造函数 - 即与类同名的方法，它引用同一个类的另一个对象。复制所有值。
析构函数 - 在销毁对象时调用。默认情况下不执行任何操作。
分配运算符 - 将一个结构/类分配给另一个结构/类时调用。这是在上述情况下调用的自动生成的方法。

Answer 3

为了保持与C的源兼容性，这种行为是必要的。

C不能让你定义/覆盖运算符，所以结构通常用=运算符复制。

Answer 4

但它是定义的。在标准中。如果您没有提供operator =，则会向您提供一个。默认运算符只复制每个成员变量。它如何知道复制每个成员的方式？它调用它们的operator =（如果没有定义，则默认提供......）。

Answer 5

赋值运算符（operator=）是C ++中结构或类的隐式生成函数之一。

以下是描述4个隐式生成成员的参考文献：
http://www.cs.ucf.edu/~leavens/larchc++manual/lcpp_136.html

简而言之，隐式生成的成员执行memberwise shallow copy。以下是链接页面的长版本：

需要时，隐式生成的赋值运算符规范如下。规范说结果是被分配的对象（self），并且后状态self中的self的抽象值的值与值相同参数from的抽象值。

// @(#)$Id: default_assignment_op.lh,v 1.3 1998/08/27 22:42:13 leavens Exp $
#include "default_interfaces.lh"

T& T::operator = (const T& from) throw();
//@ behavior {
//@   requires assigned(from, any) /\ assigned(from\any, any);
//@   modifies self;
//@   ensures result = self /\ self" = from\any\any;
//@   ensures redundantly assigned(self, post) /\ assigned(self', post);
//           thus
//@   ensures redundantly assigned(result, post) /\ assigned(result', post);
//@ }

Answer 6

如果您没有自己明确定义它们，编译器将为您合成一些成员。赋值运算符就是其中之一。复制构造函数是另一个，你也得到了一个析构函数。如果您不提供自己的构造函数，也可以获得默认构造函数。除此之外，我不确定还有什么，但我相信可能还有其他人（280Z28给出的答案中的链接虽然如此，但我记不起我现在在哪里阅读，所以也许只有四个。）

Answer 7

结构基本上是其内存中组件的串联（内置一些可能的填充用于对齐）。当您为一个结构分配另一个结构的值时，这些值只是应对。

为什么=运算符在没有定义的情况下处理结构？

7 个答案: