C-连接结构字符串元素

Question

i have two string elements in my structure

struct mystruct{
    char mydate[10];
    char mytime[5];
};

They will store strings of type "XX:YY" and "XX-YY-ZZZZ" respectively.

But when I am assigning some value into these variables

struct mystruct *mystruct = (struct mystruct*)malloc(sizeof(struct mystruct));
strcpy(mystruct->mydate, "01-01-1970");
strcpy(mystruct->mytime, "00:01");

mydate variables is printing this:

01-01-197000:01

I am missing something? Can you help me? Thanks in andance!

• EDITED with more info
• don't works even if I increase the size by one

Answer 1

You have undefined behavior since there is not sufficient room in mydate to contain strings of the format "MM-DD-YYYY" - don't forget the implicit null terminator at the end.

What you're specifically observing is that the lack of the null terminator means that the output function ( puts , printf , or whatever you're using) continues to read characters after the string ends. It so happens that there isn't any padding between mydate and mytime in your case, so the value in mytime appears to be part of the string as well.

Remember, since arrays decay to pointers when passed to functions, there is no way for a function with an array parameter to know when it is done reading the array; the null terminator acts as a sentinel value for this purpose.

Solution: Increase the size of both mydate and mytime to accommodate the null terminator as well.

Answer 2

since you complained that your code did not work even with increased sizes, here is an example which works correctly:

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

struct mystruct1 {
    char mydate[11];
    char mytime[6];
};

void main() {
    struct mystruct1 *mystruct1 = (struct mystruct1*)malloc(sizeof(struct mystruct1));

    strcpy(mystruct1->mydate, "01-01-1970");
    strcpy(mystruct1->mytime, "00:01");

    printf("date: %s, time: %s\n", mystruct1->mydate, mystruct1->mytime);
}

In this example every array has enough space to keep the string with the null terminator. So, you can compare it to your code.

In general it is also possible to keep sizes as in your example. But you need to always remember that the end of the string cannot be determined automatically and will require you to use specific function, like strncpy instead of strcpy . printf will not work directly as well. So here is another example:

struct mystruct2 {
    char mydate[10];
    char mytime[5];
};

void main() {
    struct mystruct2 *mystruct2 = (struct mystruct2*)malloc(sizeof(struct mystruct2));

    strncpy(mystruct2->mydate, "02-02-2970", 10);
    strncpy(mystruct2->mytime, "00:02", 5);

    // need top prepare standard strings with terminator for printf
    char mydate[11]; // still need [11] for printf to work
    char mytime[6];

    strncpy(mydate, mystruct2->mydate, 10);
    mydate[10] = 0; // make sure to put a string terminator here
    strncpy(mytime, mystruct2->mytime, 10);
    mytime[5] = 0;

    printf("date: %s, time: %s\n", mydate, mytime);
}

The above makes sense in some situation where you are really tight on the memory, but should not be used in generic cases.

Answer 3

The are at least two problems with the code.

1) You are writing too much in the mydate and mytime . The fix is either to allocate more memory in the struct, ie, char mydate[10+1]; & char mytime[5+1]; . Or just don't write the NULL terminator. A solution for that, since you know the size in advance, use memcpy(mystruct->mydate, "01-01-1970", sizeof(mystruct->mydate)); or similar memcpy(mystruct->mytime, "00:01", 5); .

2) The second part, print out, you are not showing (hint). So if you don't store the NULL -terminator then print out needs to be a little more delicate as shown in the example below.

// Possible dynamic max size
printf("date: %.*stime: %.*sThe\n",
       (int) sizeof(mystruct->mydate), mystruct->mydate,
       (int) sizeof(mystruct->mytime), mystruct->mytime);

// Fixed max size
printf("date: %.10stime: %.5sEnd\n",
       mystruct->mydate,
       mystruct->mytime);

Either way, the print out will be:

date: 01-01-1970time: 00:01The
date: 01-01-1970time: 00:01End

The printf -syntax used maximizes the length of the string printed.

BTW, your printout, 01-01-197000:01 , is likely the result of the compiler placing the memory layout of struct mystruct directly after each other in memory. The the resulting memory layout is equivalent to

struct mystruct {
    char my[15];
}

where the compiler knows that mydate starts at offset 0, and mytime starts at offset 10. This, if you filled your struct in the order of your example you first get "01-01-1970\\0" followed by "01-01-197000:01\\0" (where the last write is out of scope for the struct). So printing the date with printf("%s", mystruct->mydate); gives you your sequence output.

On the other hand, had you decided to write you data in the reverse order,

strcpy(mystruct->mytime, "00:01");
strcpy(mystruct->mydate, "01-01-1970");

the output of

printf("date: %s, time: %sEnd\n", mystruct->mydate, mystruct->mytime);

would be

date: 01-01-1970, time: End

since you time was overwritten my the null terminator of the mydate string copy.