C中的struct malloc问题

Question

I'm currently getting started with C, and can't come up with a solution for this.

The code:

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

struct {
   char *name;
   int ID;
   [...]
} example;  

int currentID = 1;

int new_example(char *name){

   char *the_name = malloc(strlen(name) * sizeof(char));
   example *test = malloc(sizeof(example));

   test->name = name;
   test->ID = currentID;
   currentID++;

   [...]

   return test->ID;
}

Now I know that I have to use malloc (and free) for the "name" member of that struct, as well as for the struct itself. What I'm doing right now is just allocating memory to the_name, but the test->name has no memory allocated for it. So I guess my question is, how do I write test->name into the previously malloc'd memory? Sorry if my question isn't clear enough, I don't really know how to explain it better.

Thanks in advance

Answer 1

Why don't you do something like this:

  example *test = malloc(sizeof(example));

  test->name = malloc((strlen(name) + 1) * sizeof(char)); // +1 for null terminator
  test->ID = currentID;

  strcpy(test->name, name);//copy name contents

Answer 2

Point the pointer to the new memory

char *the_name = malloc((strlen(name)+1) * sizeof(char));
example *test = malloc(sizeof(example));

test->name = the_name ;

And copy the string to it

strcpy( test->name , name )  ;

Notice that you need to allocate one more character for the null terminator:

strlen(name)+1) * sizeof(char)

Answer 3

It should look something like the following:

int new_example(char *name){

   example *test = malloc( sizeof *test ); // or calloc( 1, sizeof *test )
   if ( test ) // you should always check the result of malloc or calloc
   {   
     test->name = calloc( strlen( name ) + 1,   // + 1 for 0 terminator
                          sizeof *test->name );  
     if ( test->name )
     {
       strcpy( test->name, name );
       test->ID = currentID;
       currentID++;

       [...]
       return test->ID;
     }
     else
       free( test );
   }
   return -1; // error indication
}

Some notes:

• I prefer using sizeof *test over sizeof ( example ) ; if I ever change the type of test , I don't have to worry about changing the corresponding type in the malloc or calloc call. Same for sizeof *test->name . By definition, sizeof ( char ) == 1, so that calloc call can be written calloc( strlen( name ) + 1, 1 ) , but I still like the explicit sizeof expression in case you decide to use wchar for name (or some other wide character type).

• calloc zeros out the memory it allocates. For most types this doesn't matter, but I makes sense when allocating space for strings.

• You should always check the result of malloc and calloc calls. If you can't allocate memory for test , then you shouldn't try to allocate memory for test->name . Similarly, if you can't allocate memory for test->name , that's probably an indication of something bad, so you should back out what you've done so far.

• I am assuming that you are storing test to some persistent structure in the [...] section; if not, you have a memory leak, because you lose the test pointer when the function exits.

When you free the object, you'll want to free the name member first, like the following:

void delete_example( example *ex )
{
  free( ex->name );
  free( ex );
}

Answer 4

There's no need to allocate the memory as a separate step (but if you must, remember to add another byte for the terminating '\\0' ). Use strdup() to assign test->name directly, with its own new copy of name :

int new_example(char *name){
  example *test = malloc(sizeof(example));

  test->name = strdup(name);
  test->ID = currentID;
  currentID++;

  [...]

  return test->ID;
}

Answer 5

do

   test->name = strdup(name);

strdup will measure the string, malloc some memory, copy the string and return the malloced memory to you