使用“=”分配带有char数组的struct？

Question

I am reviewing someone's code and the developer has assigned one struct to another. The struct contains a char array. Somehow that "works", meaning the char array from struct A does get copied to struct B (not by reference). I'm totally baffled. Can so explain that to me? I have written up a little program to illustrate the "problem".

#include <stdio.h>
#include <string.h>

/**************************************
 * some define and typedef for later
 **************************************/
#define MAX_LEN (80)

typedef struct month_s
{
    char name[MAX_LEN];
} month_st;

/**************************************
 * This bit is clear.
 **************************************/
static void usingString()
{
    char mCur[MAX_LEN] = {"Jan"};
    char mNext[MAX_LEN] = {"Feb"};

    /** this doesn't compile (of course) */
    //mCur = mNext;

    /** we need a pointer/reference */
    char *pmCur = &mCur[0];

    /** however now we "copy by reference"...*/
    pmCur = &(mNext[0]);

    /** ...so this change also applies to pmCur*/
    strcpy(mNext, "Mar");

    /** ...so pmCur is now "Mar"*/
    printf("%s: %s\n", __func__, pmCur);
}

/**************************************
 * I though the same/s.th. similar
 * as above happens here. But this "works".
 * I'm surprised to see that not to be
 * the case. Can someone explain?
 **************************************/
static void usingStruct()
{
    month_st mCur = {"Jan"};
    month_st mNext = {"Feb"};

    /** I would have thought this is "copy by reference" for the string! */
    mCur = mNext;

    /** I would have thought this also overrides mCur.name
            'cause it's pointing to mNext.name now */
    strcpy(mNext.name, "Mar");

    /** how come this works??? mCur.name is still "Feb"*/
    printf("%s: %s\n", __func__, mCur.name);
}
/**************************************
 * just the main()
 **************************************/
int main()
{
    usingString();
    usingStruct();
    return 0;
}

Answer 1

What you are probably most astonished about is that arrays and pointers are not the same thing in C. An array member as in your example contains not only a pointer to the string but the string itself. Thus all theses are copied when you assign one struct instance to the other.

Answer 2

I see three explanations about the difference between pointers and arrays, but they don't seem to address the question being asked, as I understand it.

The question, as I understand it, is: "I know that I can't assign one array to another, so why can I do it if the array is inside a struct?"

The answer is, basically, "because the language said so". Even though a struct is an aggregate type, and may very well contain an array, the language spec says that structs are assignable, and therefore structs are assignable. This is section 6.5.16.1 Simple assignment in both N1256 and N1570 .

_{(Under the hood, the compiler may have to implement a memory copy, but that's the compiler's problem, not yours.)}

Answer 3

According to your declaration of struct:

typedef struct month_s
{
    char name[MAX_LEN];
} month_st;

sizeof(month_st) includes spaces for char array that is member of structs.(Notice you are doing static memory allocation, name is not pointer but array).
So when you assign one strct variable to other variable it completely copy array(or we can say total sizeof(month_st)) bytes will be copied).

Next, your are declaring two struct variables:

month_st mCur = {"Jan"};
month_st mNext = {"Feb"}; 

Memories for both variables mCur and mNext are different. When you do assignment nCur = mNext; , values of mNext copies to nCur struct variable's memory but both have separate (thier-own) memory.

strcpy() statement:

strcpy(mNext, "Mar");

effecting only variable mNext , it don't change content of variable nCur .

For your confusion, Suppose if you have declared your struct as follows:

typedef struct month_s
{
    char* name;
} month_st; 

Still by doing nCur = mNext; you copy sizeof(month_st)) bytes from mNext to nCur variable hence to only address copied as name is a pointer to a memory.

In this case complete array/memory (that you probably allocate dynamically) not copy this is called Shallow copy .

Answer 4

You are confused because you think mCur and mNext are pointers to objects, while in fact they are objects. The struct month_s merely allocates space in memory for storing the month name. It does not allocate memory for storing a pointer to anything. Thus, when mCur is assigned the value of mNext , the entire object is copied as it is copied by value and not by reference.

I have annotated your code for convenience:

static void usingStruct()
{
    month_st mCur = {"Jan"};
    month_st mNext = {"Feb"};

    /** mCur and mNext are both objects. Assigning one to the other 
      * will copy by value and not by reference (as there is no reference
      * to be copied in the first place). After this assignment, 
      * mCur == {"Feb"}  */
    mCur = mNext;

    /** mNext.name is the address of the memory allocated to the object
      * mNext. This line copies the characters "Mar" to the first three
      * bytes of this memory allocation */
    strcpy(mNext.name, "Mar");

    /** At this point, mCur == {"Feb"} and mNext == {"Mar"} */
    printf("%s: %s\n", __func__, mCur.name);
}