Why strcpy doesn't work but direct assign works?

Question

In the following code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct
{
    char** tab;
    int n;
}slist;

void print(slist* p);
void add(slist* p, const char* s);
void add(slist* p, const char* s)
{
    if(p->n==0)
    {
        p->tab=(char**)malloc(sizeof(char**));
    }
    strcpy(p->tab[p->n],s);
    p->n=p->n+1;
}
void print(slist* p)
{
    int i;
    printf("[");
    for(i=0;i<p->n;i++)
        printf(" %s",p->tab[i]);
    printf(" ]");
}
int main()
{
    char s1[25] = "Picsou";
    char s2[25] = "Flairsou";
    slist* p = (slist*)malloc(sizeof(slist));
    p->n=0;
    p->tab=NULL;
    add(p,s1);
    add(p,s2);
    print(p);
    return 0;
}

the function add() doesn't work, but if I change it to:

void add(slist* p, const char* s)
{
    if(p->n==0)
    {
        p->tab=(char**)malloc(sizeof(char**));
    }
    p->tab[p->n]=s;
    p->n=p->n+1;
}

it seems to work perfectly well. In the first case the output is only " ["; in the second case it is what is should be: " [ Picsou Flairsou ] ". I cannot understand why. I also tried this :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct
{
    char** tab;
    int n;
}slist;

void print(slist* p);
void add(slist* p, const char* s);

void print(slist* p)
{
    int i;
    printf("[");
    for(i=0;i<p->n;i++)
        printf(" %s",p->tab[i]);
    printf(" ]");
}
void add(slist* p, const char* s)
{
    slist* tmp = (slist*)malloc(sizeof(slist));
    tmp->tab=(char**)malloc(sizeof(char*)*(p->n+1));
    int i;
    for(i=0;i<p->n;i++)
         tmp->tab[i]=(char*)malloc(sizeof(char));
    strcpy(tmp->tab[p->n],s);
    tmp->n=p->n+1;
    p = tmp;
}
int main()
{
    char* s1 = "Picsou";
    char* s2 = "Flairsou";
    slist* p = (slist*)malloc(sizeof(slist));
    p->n=0;
    p->tab=NULL;
    add(p,s1);
    add(p,s2);
    print(p);
    return 0;
}

Answer 1

Lots of errors here, which is common with people who are new to dealing with pointers. Where to begin... I'll just go in the order things appear in code.

1. This is not a "list".

   It's an array... sort of. If you say "list" to a C programmer, they will think you mean a linked-list.

2. Incorrect allocation of array.

   if(p->n==0)
   {
       p->tab=(char**)malloc(sizeof(char**));
   }
   

   Here you have allocated enough to store a single pointer. The second time you call add, you're going to access memory off the end. You have also incorrectly cast the result (in C, you don't cast the return value from malloc). Additionally, you have given confusing information to the reader, because you intend to allocate an array that will hold elements of type char*, NOT char**.

   You must either allow the array to expand dynamically when required (not appropriate for your abilities right now - maybe try that in a few days), or set a maximum size. Let's do that.

   const int MAX_SIZE = 100;
   if( p->n==0 )
   {
       p->tab = malloc( MAX_SIZE * sizeof(char*) );
   }
   else if( p->n == MAX_SIZE )
   {
       printf( "Maximum size exceeded!\n" );
       return;
   }
   

   You could use calloc instead of malloc if you like. It will zero-initialise the block after allocating it: calloc( MAX_SIZE, sizeof(char*) )

3. Copying to an uninitialized pointer.

   strcpy(p->tab[p->n],s);
   

   You allocated memory for tab, but you did not allocate memory that is pointed to by its elements, and here you have undefined behaviour (most likely resulting in a segmentation fault, but could do anything).

   Make sure you have a valid pointer, and the location it points has enough storage reserved for the data you are copying into it:

   p->tab[p->n] = malloc( strlen(s) + 1 );
   strcpy( p->tab[p->n], s );
   

4. Storing potentially invalid pointer.

   Your alternative that "works perfectly well" uses:

   p->tab[p->n]=s;
   

   However, the only reason this works is because those pointers remain valid for the whole time that you use the "list" (but actually the program does not "work" because of reasons I highlighted in number 2.

   Sometimes we desire this behaviour in a program, and design our data structures to index pointers that they do not own. But more often, and especially for a beginner, you are better off copying the data (instead of simply copying the pointer). And so you'll instead use the approach I've suggested in number 3 above.

5. No comment!!

   There are so many things wrong with the following code, that I'm not going to pull it apart or explain them.

   void add(slist* p, const char* s)
   {
       slist* tmp = (slist*)malloc(sizeof(slist));
       tmp->tab=(char**)malloc(sizeof(char*)*(p->n+1));
       int i;
       for(i=0;i<p->n;i++)
            tmp->tab[i]=(char*)malloc(sizeof(char));
       strcpy(tmp->tab[p->n],s);
       tmp->n=p->n+1;
       p = tmp;
   }
   

   However, it appears like you were attempting to do something similar to realloc. This is the option I mentioned in number 2 that I said you're maybe not ready for. But read up on it anyway: realloc