CODEWITHSUNDEEP
cinitializationmalloc
Charana
Charana

Reputation: 1072

Initialising values for memory after dynamic allocation?

Im aware that malloc() returns a pointer to the initialised block of memory, but initialising this memory is difficult for me.

struct state{
    int one;
    int two;
};

struct state *one = malloc(sizeof(struct state));
*one = (struct state){.one = 10,.two = 20};
free(one);

Im aware that the above thing can be done to initialise a bunch of values for the structure without individually accessing the fields and changing the value manually.But can anyone explain how the above code works?

Also how can I do this for a pointer to several ints. The code below doesn't seem to work:

int *pointer = (int*) {1,2,3,4,5};

Upvotes: 2

Views: 89

Answers (4)

John Bollinger
John Bollinger

Reputation: 181008

But can anyone explain how the above code works?

I can explain what it means.

struct state{
    int one;
    int two;
};

That declares a structure type with tag state, which thereafter can be referenced via the type name struct state.

struct state *one = malloc(sizeof(struct state));

That declares one as a pointer to an object of type struct state. Supposing that the malloc() succeeds, it initializes one to point to a dynamically-allocated, uninitialized block of memory exactly the size of a struct state and aligned in a manner suitable for an object of that (or any other) type.

*one = (struct state){.one = 10,.two = 20};

The right-hand side of that expression is a compound literal of type struct state. The part inside the braces is its initialization list, exactly as you might use to initialize an ordinary variable of the same type:

struct state two = { .one = 10, .two = 20 };

The .one and .two name the member initialized by each individual initializer; they are optional in this particular case because in their absence, the initializer expressions would be matched to structure members in the order the members appear in the structure type declaration. Overall, the statement copies the value of the literal struct to the object pointed-to by one.

free(one);

That releases the dynamic memory block.

Also how can i do this for a pointer to several ints[?]

There is no such thing as a pointer to several ints. There is a pointer to one int, or a pointer to specific-size array of ints, but -- and I know I'm being pedantic here -- neither of those is "a pointer to several ints".

It looks like what you want in this case is an array, not (directly) a pointer. You can initialize an array and set its size in one declaration, like so:

int array[] = {1, 2, 3, 4, 5};

Afterward, you can use array in most respects as if it were a pointer to the first int in the array.

Note, however, that unlike structures, whole arrays cannot be assigned to. Although the above code may look like it contains an assignment, it does not -- it contains an initializer. Though the syntax is similar, initializers are not assignments. The latter are executable statements; the former are not.

Upvotes: 2

egur
egur

Reputation: 7970

It's best to have a function (or macro if you're into those):

struct state{
    int one;
    int two;
};

struct state* alloc_state(int one, int two)
{
    struct state s = {one, two}; // order is per struct definition!
    struct state* p = malloc(sizeof(struct state));
    memcpy(p, &s, sizeof(s));
    return p;
}

This function will always stay 4 lines of code regardless of how many argument are used. The same principle can be used with other types.

Macro version:

#define ALLOC_STATE(p, ...)   \
{                               \
    struct state s = {__VA_ARGS__}; \
    p = malloc(sizeof(struct state)); \
    memcpy(p, &s, sizeof(s));\
}

Usage:

struct state* p;
ALLOC_STATE(p, 3, 4);

Upvotes: 0

this
this

Reputation: 5290

(struct state){.one = 10,.two = 20}; is a compound literal. It is an object that remains valid until the end of the block scope. 

*one = (struct state){.one = 10,.two = 20};

Is equivalent to 

struct state temp = {.one = 10,.two = 20};
*one = temp;

In the second example, the definition of the compound literal is wrong, you must specify an array type, and then you point your pointer just like normal:

int *pointer = (int[]) {1,2,3,4,5};

Again this is equivalent to:

int temp[] =  {1,2,3,4,5} ;
int *pointer = temp;

Upvotes: 0

Sergey Kalinichenko
Sergey Kalinichenko

Reputation: 726809

can anyone explain how the above code works?

In the same way that the code below works:

int *one = malloc(sizeof(int));
*one = 1020;
free(one);

The only difference is that instead of assigning a numeric value your code assigns the value of the struct, expressed through a struct aggregate. Everything else is the same: the assignment copies the content of one region of memory into another region of memory.

Also how can i do this for a pointer to several ints?

Use memcpy, like this:

int *pointer = malloc(5*sizeof(int));
static int data[] {1, 2, 3, 4, 5};
memcpy(pointer, data, sizeof(data));
free(pointer);

Upvotes: 2

Related Questions