union within struct. compilation warnings. c

Question

I have the fallowing structs:

struct lshort_sched_param {
    int requested_time;
    int level;
};

struct sched_param {
    union {
        int sched_priority;
        struct lshort_sched_param lshort_params;
    };
};

and i'm trying to create a new instance of them like so:

struct lshort_sched_param *l = {2 ,1};
struct sched_param *p = {3, l}; 

and get some warnings:

test.c:5: warning: initialization makes pointer from integer without a cast
test.c:5: warning: excess elements in scalar initializer
test.c:5: warning: (near initialization for `l')
test.c:6: warning: initialization makes pointer from integer without a cast
test.c:6: warning: excess elements in scalar initializer
test.c:6: warning: (near initialization for `p')

can anyone help me figure it out?

Answer 1

You are declaring pointers, but they have to point something before you try to modify the thing that are pointed by them, and that can be done with malloc like this.

struct lshort_sched_param *l = NULL;
l = malloc(sizeof(struct lshort_sched_param));

struct sched_param *p = NULL;
p = malloc(sizeof(struct sched_param));

What are we doing?. Well, malloc allocates some bytes on memory and return a pointer to the beginning of the block, and in our case we are assigning the pointer returned by malloc to our pointers l and p, the result is that now l and p are pointing to the structures that we just made.

Then you can change the value of the structures pointed by p and l in this way.

l->requested_time = 2;
l->level = 1;
p->sched_priority = 3;
p->lshort_params.requested_time = 1;
p->lshort_params.level = 1;

Edit:

Obviously, you can also do this.

struct lshort_sched_param p = {2, 1};

and then.

struct lshort_sched_param *ptr = &p;

But when you are doing.

struct lshort_sched_param *l;

You are only declaring a pointer and nothing more, it's not pointing to anything until you assing him the adress of a variable.

Answer 2

I think you wanted to do the following:

struct lshort_sched_param {
    int requested_time;
    int level;
};

union sched_param {
    int sched_priority;
    struct lshort_sched_param lshort_params;
};

To allocate memory for the struct/union do the following:

struct lshort_sched_param l = {2 ,1};
union sched_param p;
// init
// either this
p.sched_priority = 3;
// or that
p.lshort_params = l;

Your line struct sched_param *p = {3, l}; does not make sense.

Answer 3

This is not permitted:

struct lshort_sched_param *l = {2 ,1};

Brace-enclosed initializer lists with more than one element can only initialize a struct or an array, not a pointer.

You could write:

struct lshort_sched_param m = { 2, 1 };
struct lshort_sched_param *ptr_m = &m;     // optional

You also need to think about the storage duration of m. (NB. I have used m instead of l as a variable name as the latter looks like 1 in many fonts).

Another possibility is:

struct lshort_sched_param *ptr_m = (struct lshort_sched_param) { 2, 1 };

and in this case you are allowed to modify the object that ptr_m points to. This is called a compound literal. It has automatic storage duration ("on the stack") if ptr_m does; otherwise it has static storage duration.

---

Things get worse with struct sched_param *p = {3, l}; however. Again, the initializer cannot initialize a pointer.

Also, union initializers can only have one element; it's not permitted to try and initialize more than one member of a union. Which doesn't make sense anyway. (perhaps you misunderstand how unions work).

Another possible problem is that initializers at file scope must be constant expressions.