Thread: mallocating a struct

struct database_input {
char *catA;
int catB;
double catC;
int catD;
};

lets say i want to establish an array of structs called data, and I want to dynamically allocated .

So far I have written this:

Code:

data = malloc((i+1) * sizeof(*data)); //where i+1 is the size I want

while(j<i) //where j starts off 0 and i is the last index
{
 printf("size: %d\n", sizeof(data));
data[j].catA = (char*)malloc(strlen(a[j])*sizeof(char));  
//a is an array of strings (char**) so a[j] is the string inposition j.

j++;
}

I didn't continue on because when I tried to compile it, a segmentation error occurs at the lines data[j].branchnumber...

Did I do something wrong, how can I fix this?

Thanks

> data = malloc((i+1) * sizeof(*data));
Given your while loop which follows, you only need 'i' elements, not i+1

> data[j].catA = (char*)malloc(strlen(a[j])*sizeof(char));
If you're following this with strcpy to data[j].catA, then you're 1 char short.
strlen() doesn't count the \0, but strcpy will copy it.

Say
data[j].catA = malloc( (strlen(a[j])+1)*sizeof(*data[j].catA) );

hi,
I tried that and the error is still the same, hangs at the same line.

Here is an example on how to malloc structs and there member data.

Code:

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

struct infoStruct{
	char *data;
	int value;
};

int main()
{
	const int bufSize = 10;
	int i = 0;
	struct infoStruct *pInfoStruct = NULL;

	/*Allocate our struct out*/
	pInfoStruct = malloc(sizeof(struct infoStruct) * bufSize);

	/*Make sure our struct was allocated*/
	if(NULL == pInfoStruct){
		return 0;
	}/*if*/

	/*Allocate our member data*/
	for(i = 0; i < bufSize; i++){
		/*Allocate the string*/
		pInfoStruct[i].data = malloc(sizeof(char) * bufSize);
		
		if(NULL == pInfoStruct[i].data){
			break;
		}/*if*/

		/*Copy Hello into the data buffer*/
		strcpy(pInfoStruct[i].data, "Hello");

		/*Set the value to i*/
		pInfoStruct[i].value = i;
	}/*for*/

	/*Print out the value*/
	for(i = 0; i < bufSize; i++){
		/*Make sure we have valid data*/
		if(NULL == pInfoStruct[i].data){
			break;
		}/*if*/

		printf("&#37;s: %d\n", pInfoStruct[i].data, pInfoStruct[i].value);
	}/*for*/

	/*So we can see it*/
	getchar();

	/*Free Up The Values*/
	for(i = 0; i < bufSize; i++){
		free(pInfoStruct[i].data);
	}/*for*/

	free(pInfoStruct);

	return 0;
}

I think the comments and such in the code should handle the explaination.

> I tried that and the error is still the same, hangs at the same line.
Unfortunately, when dealing with malloc related problems, you have to examine all your use of malloc, not just the one which is failing.

If you repeated the same "off-by-one" mistake somewhere else in the code, then those need to be fixed as well.

If you can, post a complete program which crashes. Short snippets are not going to help since we can easily make the snippets work perfectly in isolation, but they will still fail in your main program.

Originally Posted by philip79

Is it not quite illegal to dereference an uninitialized pointer or null pointer (the original post does not say). I'm refering to the usage of *data together with the sizeof operator.

You're right that you cannot dereference an uninitialized or null pointer. However, in sizeof(*data), you're not derefencing. It's taking the size of the structure itself, not the pointer. Consider this example:

Code:

#include <stdio.h>

struct databucket
{
	int data1, data2, data3, data4, data5;
};

int main()
{
	struct databucket *somedata;

	somedata = NULL;

	printf("sizeof(somedata) = &#37;u\n", sizeof(somedata));
	printf("sizeof(*somedata) = %u\n", sizeof(*somedata));

	return 0;
}

That will output:

Code:

sizeof(somedata) = 4
sizeof(*somedata) = 20

Where 20 is the size, in bytes, of a "databucket" structure, and 4 is the size, in bytes, of a pointer, on my system.

Do it like this instead:

Code:

data = malloc( i * sizeof( struct database_input ) )

The argument against doing that is that if you ever change data's type, you must also change the associated malloc() statements (and anywhere else you use sizeof()).