Structures and dynamically allocated arrays

Hi, I'm a novice when it comes to programming. Right now I'm in college taking my first class on C++, but our first homework assignment is in C.

Anyways, the first programming assignment is fairly large and I've been working on it for a few days now.

However, there's a certain part of the program where I'd love to utilize structures and dynamically allocated arrays for a specific purpose.

I created a test program in C to kinda test out what I want to do...but I can't get it to compile. (If it doesn't compile, then surely it won't work in the grand scheme of things.)

I would be grateful if anyone can point me in the right direction and help me find a solution for what I want to accomplish.

Basically I'm trying to create a structure that contains a dynamically allocated array of structures, with each of these structures containing a dynamically allocated array of integers. So far I've been unsuccessful in getting something like this to compile (I use g++ if that matters)...

Code:

---



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

// I want to create a "parent structure"
// that is capable of holding a dynamically allocated
// array of "child structures"
//
// each of these "child structures" would then hold
// a dynamically allocated array of integers..


// "child structure"
typedef struct {
        int *numbers; // dynamically allocated array of ints
} child_structure;

// "parent structure"
typedef struct {
        child_structure *items; // dynamically allocated array of child stucts
} parent_structure;

int
main(void)
{
        parent_structure test;

        int N, n;

        // first i dynamically allocate the array of child structures...

        test.items = (child_structure *)malloc(sizeof(child_structure) *N);

      // then i dynamically allocate the array of integers in each of child structures
      // ... at least that's what i'm trying to do!

        test.items.numbers = (int *)malloc(sizeof(int) *n);

        return (0);
}

---

I've fiddled around a bit...but I can't get it to compile. What am I doing wrong? Is there some kind of looping involved?

Thanks in advance for the help.

Code:

---

test.items.numbers = (int *)malloc(sizeof(int) *n);

---

items is a pointer, so you must dereference it accordingly.

Code:

---

test.items->numbers = (int *)malloc(sizeof(int) *n);

---

Look at my inlines for comments

Code:

---

int main(void)
{
        parent_structure test;

        int N, n; 
        // the values are initialised. The would be a major problem while dynamically allocating
        // N = n = 10;
       
        // DO NOT typecast the return of malloc. It already returns of type void *
        // Always check for the return value of malloc.
        // if( ( test.items = malloc( sizeof( child_structure ) * N ) == NULL ) print( ERROR );
        // else print( PASS );
        test.items = (child_structure *)malloc(sizeof(child_structure) *N);
       
        // You cant do this, because of the operator precidences.
        // test.items->numbers = malloc( sizeof( int ) * n );
        // And error handling here. VERY IMPORTANT!
        test.items.numbers = (int *)malloc(sizeof(int) *n);
       
        getchar();
        return (0);
}

---

~ssharish

Couple of things: there is no purpose to casting malloc in C:

Code:

---

test.items = (child_structure *)malloc(sizeof(child_structure) *N);

---

Also: you have not initialized N or n to any value!

Next: What bithub says is true UNLESS you actually want "items" to be a " dynamically allocated array of ints". Look:

Code:

---

parent_structure test;

---

One struct, with a member, items, which is supposed to be an array. But

Code:

---

test.items = malloc(sizeof(child_structure) *N);
test.items.numbers = (int *)malloc(sizeof(int) *n);

---

That's not an array! You want:

Code:

---

for (i=0; i<N; i++) {
    test.items[i].numbers = malloc(sizeof(int) *n);
}

---

Get it?

You can do it the other way, but then you cannot access elements of test.items via array[subscripting] -- you must use pointer arithmetic on each element. Also, you would have to malloc test.items N*n*sizeof(int).

Thank you everyone for the swift and very helpful input!

MK27 your advice on using the for loop made perfect sense! I was already thinking that some kind of loop was needed, but wasn't sure...but since I plan to access the arrays using subscripting, that was the info I needed.

Quick question, you guys said that in C you don't need to cast the mallocs...but is there any harm in doing it anyway?

The reason I'm asking is because I'll be implementing a lot of these kinds of structures in my programming assignment, and my professor requires us to submit our assignment by turning in the source code. He said that the TA's will be strictly using g++ to compile all our programs and grade them. If it doesn't compile then we lose points.

The thing is, if I don't typecast the mallocs, then it'll compile just fine in gcc, but it won't compile in g++. If I typecast them, then it compiles in g++.

Quote:

---

Originally Posted by Bandizzle

The thing is, if I don't typecast the mallocs, then it'll compile just fine in gcc, but it won't compile in g++. If I typecast them, then it compiles in g++.

---

I guess that is the answer then. No, it will not do any harm AFAIK.

>Quick question, you guys said that in C you don't need to cast the mallocs...but is there any harm in doing it anyway?

Read this

~ssharish

Quote:

---

Originally Posted by Bandizzle

Thank you everyone for the swift and very helpful input!

MK27 your advice on using the for loop made perfect sense! I was already thinking that some kind of loop was needed, but wasn't sure...but since I plan to access the arrays using subscripting, that was the info I needed.

Quick question, you guys said that in C you don't need to cast the mallocs...but is there any harm in doing it anyway?

The reason I'm asking is because I'll be implementing a lot of these kinds of structures in my programming assignment, and my professor requires us to submit our assignment by turning in the source code. He said that the TA's will be strictly using g++ to compile all our programs and grade them. If it doesn't compile then we lose points.

The thing is, if I don't typecast the mallocs, then it'll compile just fine in gcc, but it won't compile in g++. If I typecast them, then it compiles in g++.

---

You will want to stick with one way, since C does not require it and it might just hide a grave error, but in C++, it is required, and the pitfall that exists in C does not exist either, so it is safe.
Since you are a C++ programmer, though, I suppose I should advise you to cast the return and compile with a C++ compiler.