如何使结构内的指针指向另一个指针指向的同一个字符串？

Question

I have the following code:

struct el{      
    char *line;
    struct el *next;
};

struct el *abc, def;
char *p1;
char buffer[100];

abc = &def;
gets(buffer);
p1 = malloc(strlen(buffer) + 1 );
strcpy( p1, buffer);

How can I make line point to the same string pointed by p1 without allocating the same string twice? Is it enough to write:

 abc->line = p1;

Or do I also need to free the area pointed by p1 ?

Answer 1

I sense something smelly... Namely, that all your variables seem to be local variables (on the stack) that cease to exist when your function returns.

So would your function end with

return abc;

then you loose everything because you said abc= &def; and def is also a local variable. So yes, you can simply do abc->line= p1; but after the return you have lost abc (which points to def which was a stack variable that then no longer exists) and hence you have also lost abc->line and so you have a memory leak.

So you should expand the code you show us for us to be able to say "Yes you can do that".

The following is an example of a function that is wrong:

struct el{
    char *line;
    struct el *next;
};

struct el *example(void)
{
    struct el *abc, def;    // def is a local variable
    char *p1;
    char buffer[100];
        
    abc = &def;
    gets(buffer);
    p1 = malloc( strlen(buffer) + 1 );
    strcpy( p1, buffer);
    
    abc->line= p1;
    return abc;             // def won't exist anymore after the function returns
}

To fix this error, you should also do abc= malloc(sizeof(struct el)); or pass a pointer variable to the function, for example:

void example2(struct el *abc)
{
    char *p1;
    // ...
    abc->line= p1;
 }

and call as for example:

int main(void)
{
    struct el pqr = {0};
    example2(&pqr);
    // ...
}

Answer 2

How can I make line point to the same string pointed by p1 without allocating the same string twice? Is it enough to write:

 abc->line = p1;

Yes, you can do that. abc->line will be pointing to the same memory address as p1 .

Or do I also need to free the area pointed by 'p1'?

No, you don't need to free both. You should either use:

free(abc->line);

or:

free(p1);

You only need one of them, as both pointers are pointing to the same memory address, when you free one you free both.

Note that by freeing abc->line , p1 will become a dangling pointer, it will be pointing no nothing meaningful.

Recommended read regarding gets .

Answer 3

First, using gets() is not recommended. A good replacement is fgets() .

How can I make 'line' point to the same string pointed by 'p1' without allocating >the same string twice?

Two pointers can both point to the same buffer simply by setting them to point to the address of the buffer. Dynamic memory allocation is not necessary. Given your code:

//the following are created in file global scope
struct el{
    char *line;
    struct el *next;
};

struct el *abc, def; 

char *p1;
char buffer[100];

//The following is performed in local scope within a function, using global variables created above.
p1 = &buffer[0];//assign address of buffer to pointer p1
//same for char *line:
abc->line = &buffer[0];//assign address of buffer to member *line

//both will now accept input using fgets()
fgets(p1, sizeof(buffer), stdin);
fgets(abc->line, sizeof(buffer), stdin);

Answer 4

How can I make line point to the same string pointed by p1 without allocating the same string twice? Is it enough to write abc->line = p1 ?

Yes. abc->line = p1; is correct.

Or do I also need to free the area pointed by p1 ?

No, not at all. In opposite, If you would do so, line would point to nowhere.

Note that abc->line = p1; only assigned the value of the memory address of the chunk allocated by malloc() from p1 to the structure member line . They both are references to the **same ** memory allocated by malloc() .

---

Never ever use gets() . Reason why is here . It is also removed from the C standard since C11.