Thread: Structure Passing, Index Problem

Why is this acting strange? Can someone explain why the first index doesn't print and why it increments into non-allocated memory?

Code:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define BUFSIZE 25


struct tag{
    char *first,
    *middle,
    *last;
};


struct social{
    struct tag name;
    char *socialnum;
};


void printdata(struct social a);


int main (int argc, const char * argv[]) 
{
    struct social fellow[5] = {
    {
        (char*)malloc(sizeof(char)*BUFSIZE), 
        (char*)malloc(sizeof(char)*BUFSIZE),
        (char*)malloc(sizeof(char)*BUFSIZE),
    },
        
    (char*)malloc(sizeof(char)*BUFSIZE),    
    };
    
    fellow[0].name.first = "Ally";
    fellow[0].name.middle = NULL;
    fellow[0].name.last = "Anderson";
    fellow[0].socialnum = "123456789";
    
    fellow[1].name.first = "Benny";
    fellow[1].name.middle = "Benjamin";
    fellow[1].name.last = "Baker";
    fellow[1].socialnum = "234567891";
    
    fellow[2].name.first = "Cathy";
    fellow[2].name.middle = NULL;
    fellow[2].name.last = "Cenders";
    fellow[2].socialnum = "345678912";
    
    fellow[3].name.first = "Darell";
    fellow[3].name.middle = "Dimebag";
    fellow[3].name.last = "Deezy";
    fellow[3].socialnum = "345678912";
    
    fellow[4].name.first = "Edward";
    fellow[4].name.middle = NULL;
    fellow[4].name.last = "Edison";
    fellow[4].socialnum = "456789123";


    for (int i=0; i < 5; i++)
    {
        printdata(fellow[i]);
    }
    free(fellow);
    
    puts("\n");
    return 0;
}


void printdata(struct social a)
{
     printf("\n");
     printf("%s, %s ", a.name.last, a.name.first);
     if (a.name.middle) 
          printf("%c. ", toupper(*a.name.middle) );
    printf("-- %s", a.socialnum);
}

Output:
//NULL - This is 0 index
Anderson, Ally -- 123456789 // 1 index
Baker, Benny B. -- 234567891 // 2 index
Cenders, Cathy -- 345678912 // 3 index
Deezy, Darell D. -- 345678912 // 4 index
(gdb) continue
Prob4(5304) malloc: *** error for object 0x7fff5fbff6f0: pointer being freed was not allocated
*** set a breakpoint in malloc_error_break to debug
Edison, Edward -- 456789123

Wow. Your code is almost a case study on maximising the number of ways to get things wrong.

1) Do not use assignment to copy string literals into a character buffer. Use strcpy() (which is declared in the standard header <string.h>). For example;

Code:

    strcpy(fellow[0].name.first, "Ally");       /*  not  fellow[0].name.first = "Ally"; */

2) If you want to set a buffer to NULL, you need to free it first.

Code:

free(fellow[0].name.middle);
fellow[0].name.middle = NULL;

Note that, if you do this, and want to assign a string again, you need to do

Code:

fellow[0].name.middle = malloc(BUFSIZE);   /* reallocate.   See note 4 below for why I have removed sizeof(char) */
strcpy(fellow[0].name.middle, "Gator");

Keep in mind that strcpy() cannot accept NULL pointers as either argument (the resultant behaviour is indefined).

3) Only free things you have malloced. The call free(fellow) is invalid, since fellow is not a pointer returned by malloc(). Instead you need to do

Code:

for (int i = 0; i < 5; ++i)
{
    free(fellow[i].name.first);
    free(fellow[i].name.middle);
    free(fellow[i].name.last);
    free(fellow[i].socialnum);
}

With this, you don't need to worry if any of the pointers are NULL. free() correctly handles a NULL pointer, by doing nothing.

4) The C standard defines sizeof(char) to be 1. You do not need to compute it.

Originally Posted by ChipS

Why can't I use an assignment when I'm using a char* type vs an array?

You can't assign an entire array with an equal sign*.


Quzah.

Originally Posted by ChipS

Why can't I use an assignment when I'm using a char* type vs an array?

Because the assignment is of pointers, not of the contents of the array.

The assignment "some_pointer = some_array;" is valid, but is technically equivalent to "some_pointer = &some_array[0];" It does not copy elements of the array.

So, if you do this;

Code:

    char *x = malloc(25);
    x = "Hello";
    free(x);

the behaviour is invalid. The assignment changes the value of x so it contains the address of the first character of "Hello". It does not copy contents of the string "Hello" into the 25 character buffer supplied by malloc(). The malloced memory is lost (since the value of x itself has changed) so the free() call gives undefined behaviour.

The other problem I neglected to mention in my previous post is that your creation of fellow is invalid

Code:

struct social fellow[5] = {
    {
        (char*)malloc(sizeof(char)*BUFSIZE), 
        (char*)malloc(sizeof(char)*BUFSIZE),
        (char*)malloc(sizeof(char)*BUFSIZE),
    },
        
    (char*)malloc(sizeof(char)*BUFSIZE),    
    };

This initialises fellow[0] so it contains four char pointers, each returned by malloc(). It does not replicate the malloc() calls for fellow[1] through fellow[4]. They get initialised to zero (the NULL pointer).

So setting fellow[1].name.<anything> or fellow[1].socialnum to anything (whether by a pointer assignment, or using strcpy()) is invalid.

Ok thanks, fixed the memory problem. That was something I kind of just threw in there without thinking about to be honest. Can you explain why the program seems to skip the 0 index and output "Ally" on the 1st index instead?

Code:

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


#define BUFSIZE 25


struct tag {
    char *first,
         *middle,
         *last;
};


struct social {
    struct tag name;
    char *socialnum;
};


void printdata(struct social a);


int main (int argc, const char * argv[])
{
    struct social fellow[5];


    for (int i=0; i < 5; i++)
    {
        fellow[i].name.first = malloc(BUFSIZE);
        fellow[i].name.middle = malloc(BUFSIZE);
        fellow[i].name.last = malloc(BUFSIZE);
        fellow[i].socialnum = malloc(BUFSIZE);
    }

    strcpy(fellow[0].name.first, "Ally");
    strcpy(fellow[0].name.middle, "Amy");
    strcpy(fellow[0].name.last, "Anderson");
    strcpy(fellow[0].socialnum, "123456789");

    strcpy(fellow[1].name.first, "Benny");
    strcpy(fellow[1].name.middle, "Benjamin");
    strcpy(fellow[1].name.last, "Baker");
    strcpy(fellow[1].socialnum, "234567891");

    strcpy(fellow[2].name.first, "Cathy");
    strcpy(fellow[2].name.middle, "Cedar");
    strcpy(fellow[2].name.last, "Cenders");
    strcpy(fellow[2].socialnum, "345678912");

    strcpy(fellow[3].name.first, "Darell");
    strcpy(fellow[3].name.middle, "Dimebag");
    strcpy(fellow[3].name.last, "Deezy");
    strcpy(fellow[3].socialnum, "456789123");

    strcpy(fellow[4].name.first, "Edward");
    strcpy(fellow[4].name.middle, "Eddy");
    strcpy(fellow[4].name.last, "Edision");
    strcpy(fellow[4].socialnum, "567891234");

    for (int i=0; i < 5; i++)
    {
        printdata(fellow[i]);
    }
    for (int i=0; i < 5; i++)
    {
        free(fellow[i].name.first);
        free(fellow[i].name.middle);
        free(fellow[i].name.last);
        free(fellow[i].socialnum);
    }


    puts("\n");
    return 0;
}


void printdata(struct social a)
{
    printf("\n");
    printf("%s, %s ", a.name.last, a.name.first);
    if (a.name.middle)
        printf("%c. ", *a.name.middle );
    printf("-- %s", a.socialnum);
}

Code:

 strcpy(fellow[0].name.first, "Ally");
 strcpy(fellow[0].name.last, "Amy");
 strcpy(fellow[0].name.last, "Anderson");

Copy-paste strikes again.


Quzah.

Why do people do this to themselves?

Code:

struct tag {
    char *first,
         *middle,
         *last;
};


struct social {
    struct tag name;
    char *socialnum;
};

when they could simply do this...

Code:

struct social
  { char *fname;
    char *mname;
    char *lname;
    char *socialnum; }

or even better.... this...

Code:

#define MAX_FNAME 16
#define MAX_MNAME 16
#define MAX_LNAME 24
#define MAX_SOCIALNUM 16


struct social
  { char fname[MAX_FNAME];
    char mname[MAX_MNAME];
    char lname[MAX_LNAME];
    char socialnum[MAX_SOCIALNUM]; }

Which gives them simpler access, in-struct storage and predefined buffer sizes for the rest of their code....

Originally Posted by CommonTater

Which gives them simpler access, in-struct storage and predefined buffer sizes for the rest of their code....

Easy if you're writing your own code. Much harder to use your technique if you are required to reuse data structures, support functions from a third-party library.. In those circumstances, nested structures are often useful.

Your technique also hard-codes buffer lengths, which is useless if buffer lengths cannot be determined until run time.

Either way, the techniques ChipS is trying to learn do have their uses.