在赋值运算符函数中，隐式数组是memcpy

Question

OK。我们知道以下代码无法编译。

char source[1024]; 
char dest[1024]; 
// Fail. Use memcpy(dest, source, sizeof(source)); instead. 
dest = source; 

但是，下面的代码可以被编译并且行为正确。

class A { 
    char data[1024]; 
}; 
A source; 
B dest; 
dest = source; 

我想知道，在运算符赋值函数中，数组是隐式的吗？

以下是完整的测试代码。

---

#include <cstdio> 
#include <memory> 

class A { 
public: 
    char data[1024]; 
}; 

int main() { 
    { 
     A source; 
     A dest; 

     // Initialization 
     char *data = "hello world"; 
     memcpy (source.data, data, strlen(data) + 1); 

     printf ("source.data = %s\n", source.data); 
     printf ("address source.data = %x\n", source.data); 

     // Works! Does this in the operator assignment function, memcpy is 
     // being performed implicitly on array. 
     dest = source; 

     printf ("dest.data = %s\n", dest.data); 
     printf ("address dest.data = %x\n", dest.data); 
    } 

    { 
     char source[1024]; 
     char dest[1024]; 

     // Initialization 
     char *data = "hello world"; 
     memcpy (source, data, strlen(data) + 1); 

     printf ("source = %s\n", source); 
     printf ("address source = %x\n", source); 

     // '=' : left operand must be l-value 
     // dest = source; 
     // Works with memcpy. 
     memcpy(dest, source, sizeof(source)); 

     printf ("dest = %s\n", dest); 
     printf ("address dest = %x\n", dest); 
    } 

    getchar(); 
} 

//RESULT : 
//source.data = hello world 
//address source.data = 12fb60 
//dest.data = hello world 
//address dest.data = 12f758 
//source = hello world 
//address source = 12f344 
//dest = hello world 
//address dest = 12ef3c 

Answer 1

编译器生成的复制构造函数/分配-op是逐位拷贝，如果找到符合的子元素没有复制构造函数/赋值运算。

编辑：
这是修改后的测试用例，显示了这个概念。

#include <cstdio> 
#include <memory> 

class someElement 
{ 
public: 
    someElement() : theData(0) {} 
    // Intentionally copy-edit 
    someElement(const someElement& src) : theData(src.theData + 1) {} 
    ~someElement(){} 

    someElement& operator=(const someElement& rhs) 
    { 
     theData = rhs.theData - 1; 
     return *this; 
    } 

    char theData; 
}; 

class A { 
public: 
    someElement data[1024]; 
}; 

int main() { 
    { 
     A source; 
     A dest; 

     // Initialization 
     char *data = "hello world"; 
     memcpy (source.data, data, strlen(data) + 1); 

     printf ("source.data = %s\n", source.data); 
     printf ("address source.data = %x\n", source.data); 

     // Works! Does this in the operator assignment function, memcpy is 
     // being performed implicitly on array. 
     dest = source; 

     printf ("dest.data = %s\n", dest.data); 
     printf ("address dest.data = %x\n", dest.data); 
    } 

    { 
     someElement source[1024]; 
     someElement dest[1024]; 

     // Initialization 
     char *data = "hello world"; 
     memcpy (source, data, strlen(data) + 1); 

     printf ("source = %s\n", source); 
     printf ("address source = %x\n", source); 

     // '=' : left operand must be l-value 
     // dest = source; 
     // Works with memcpy. 
     memcpy(dest, source, sizeof(source)); 

     printf ("dest = %s\n", dest); 
     printf ("address dest = %x\n", dest); 
    } 

    getchar(); 
} 

Answer 2

operator=，如果没有明确落实，执行的类的内容的成员复制。对于你的封装数组，这将起作用，但是通常需要注意确保对类的数据进行适当的深层复制。

Answer 3

标准的这句话有帮助吗？这是安静的自我解释

对不起，删除我以前的答案是有关复制构造函数，而不是复制赋值运算符。

$ 12.8/30-

的隐式定义的拷贝赋值运算符 对非工会类X 执行按成员拷贝的 其子对象的分配。直接基 类X首先被分配，在 其声明中 基本符列表的顺序，然后X 的 直接非静态数据成员被分配在顺序 他们在类别 定义中声明。 - ;即，忽略任何如果子对象是类的类型， 为 类的拷贝赋值运算符被使用（如，如果通过显式 资格

：每个子对象以适合其种类的方式分配 更多派生类中可能的虚拟覆盖函数 ）;

- 如果 子对象是一个数组，每一个元素是 分配，以适合于 元素类型的方式;

- 如果子对象 是标量类型，则使用内置的 赋值运算符。