CODEWITHSUNDEEP
carrayspointersallocationstructure
Kevin Lloyd Bernal
Kevin Lloyd Bernal

Reputation: 363

dynamically allocate arrays of pointers to structures in C

I have this structure here:

typedef struct _open {
    int x;
    struct _open *next;
} *NODE;

And on my main function I declared this pointer:

NODE open = initOpen(size);

Here's the initOpen function:

NODE initOpen(int size) {
    return (NODE)malloc(sizeof(struct _open)*size);
}

I this correct? can I access my array in the main function like: open[0] to open[9] ?

Upvotes: 1

Views: 1112

Answers (2)

pochen
pochen

Reputation: 873

First of all, the way you are doing dynamically allocated array is wrong.
I'm not sure if you actually want the thing you wrote, which is linked list, or the thing you said, which is dynamically allocated array.

Below is how you should do dynamically allocated array. Hope it helps. By doing so, you can add as many ints into the array as you want, before you run out of memory. And you can access the array using array notation but with a pointer first: darray->array[0]

Your linked list, however, can not be accessed with this syntax.

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

#define INITSIZE 8

typedef struct dyarr{
    int num;
    int max;
    int *array;
}arr;

arr* makeArr();
void add( arr*, int );

int main( int argc, char const *argv[] ){
    int t;
    arr* darray = makeArr();
    while( scanf( "%d", &t ) != EOF ){
        add( darray, t );
    }
    int i;
    for( i = 0; i<darray->num; i++ ){
        printf( "%d\n", darray->array[i] );
    }
    getchar();
    return 0;
}

arr* makeArr(){
    arr* A = malloc( sizeof( arr ) );
    A->max = MAXSIZE;
    A->num = 0;
    A->array = malloc( sizeof( int )*A->max );
    return A;
}

void add( arr* a, int i ){
    if( a->num == a->max ){
        a->max *= 2;
        a->array = realloc( a->array, a->max );
    }
    a->array[a->num++] = i;
}

Upvotes: 1

fso
fso

Reputation: 154

First of all, you should respect some conventions:

typedef struct node {
    int x;
    struct node *next;
} *nodePtr;

Second, what is the usage of the parameter size ? According to me the right way to allocate a new nodePtr is:

nodePtr initNodePtr() {
    return (nodePtr)malloc(sizeof(struct node));
}

Also dont forget to release memory after usage:

nodePtr node = initNodePtr();
...
...
free(node); //should be wrapped in a function to respect design.

To Create an array of structure, you should do the following:

typedef struct {
    int x;
    node* next;
} node;

int main() {
    node* nodeArray = (node*)malloc(sizeof(node)*50); // 50 = size of your array
    ...
    // do whatever you want
    ...
    free(nodeArray);   
}

Not tested, let me know if errors.

Upvotes: 0

Related Questions