In assignment operator function, is array being memcpy implicitly

Question

OK. We know the following code cannot be compiled.

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

But, the following code can be compiled and behave correctly.

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

I was wondering, in operator assignment function, is array will be memcpy implicitly?

The following are the complete test code.

---

#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

compiler generated copy-ctor / assignment-op is bitwise-copy if no copy-ctor / assignment-op found for the child elements.

Edit:
Here is the modified test case showing the concept.

#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=, if not explicitly implemented, performs a memberwise copy of the class's contents. For your encapsulated array this will work but in general care is needed to ensure proper deep copying of the class's data.

Answer 3

Does this quote from the Standard help? It is quiet self explanatory

Sorry, removed my earlier answer which was related to copy constructor and not copy assignment operator.

$12.8/30-

The implicitly-defined copy assignment operator for a non-union class X performs memberwise copy assignment of its subobjects. The direct base classes of X are assigned first, in the order of their declaration in the base-specifier-list, and then the immediate non-static data members of X are assigned, in the order in which they were declared in the class definition. Each subobject is assigned in the manner appropriate to its type:

— if the subobject is of class type, the copy assignment operator for the class is used (as if by explicit qualification; that is, ignoring any possible virtual overriding functions in more derived classes);

— if the subobject is an array, each element is assigned, in the manner appropriate to the element type;

— if the subobject is of scalar type, the built-in assignment operator is used.