初始化指向 const 指针的指针

Question

Is what am I trying to do in C possible?

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

struct foo{
    int const * const a;    // constPtrToConst is a constant (pointer)
                            // as is *constPtrToConst (value)
};

struct faa{
    int b;
};

int main(void){
    struct foo *x = (struct foo*)malloc(sizeof(struct foo));
    struct faa *y = (struct faa*)malloc(sizeof(struct faa));

    x->a = &(y->b);     // error: assignment of read-only member ‘a’ [that's ok] 
                        // (I)
    x->a++;    // It should not do this either...

    printf("%d,\t%p\n", *(x->a), x->a);    // (II)
    free(x);
    free(y);
}

How can I initialize (I) and could I get this (II)?

Sorry is not assign is initialize with that pointer.

This is what I want to get but dynamically.

#include <stdio.h>

struct foo{
    int const * const a;
};

int main(void){
    int b = 5;
    struct foo x = {
        .a = &b
    };
    printf("%d\n", *(x.a));
}

This is how I solve it.

I don't know if is the best choice.

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

struct foo{
    int const * const a;
};

struct foo* newfoo(int *var){
    struct foo *tempD = malloc(sizeof(struct foo));
    struct foo tempS ={
        .a = var
    };
    memcpy(tempD, &tempS, sizeof(struct foo));

    return tempD;
}

int main(void){
    int b = 5;

    struct foo *z = newfoo(&b);

    printf("%d,\t%p\n", *(z->a), z->a);
    // this is equivalent to printf("%d,\t%p\n", b, &b);

    free(z);
}

Answer 1

int const * const a; is a type of variable which is constant means that it cannot be changed (second const), while first const means that it points to constant data.

Change your structure to:

struct foo{
    const int* a;
};

Now you can assign value to a but you cannot modify value where a points.

struct foo myFoo;
myFoo.a = (int *)5; //a points to location 5 now, valid
*myFoo.a = 4;       //Try to modify where a points = invalid and error

What is the difference between const int*, const int * const, and int const *?

Answer 2

You have to use memcpy in this case; you can't assign through a const expression:

int *temp = &y->b;
memcpy((void *)&x->a, &temp, sizeof temp);

In order to effect x->a++ you could do:

int *temp;
memcpy(&temp, &x->a, sizeof temp);
++temp;
memcpy((void *)&x->a, &temp, sizeof temp);

Answer 3

You can't assign to x->a after initialization, so you would have to do something silly like:

struct faa *y = (struct faa*)malloc(sizeof(struct faa));
struct foo tmp = {&y->b};
struct foo *x = (struct foo*)malloc(sizeof(struct foo));
memcpy(x, &tmp, sizeof *x); 

Answer 4

This is the same scenario:

• I locked the door and threw away the key since nobody including myself should ever open that door in any situation.
• Immediately after doing that, I noticed that I cannot open the door!
• I need to open this door! How do I do that? I threw away the key.

You have to 1) know what you are doing, and 2) don't do things that you actually don't want to do, including not making a program design specification that contradicts the actual needs of the program.

Simply change the declaration to int const* a; if you intend to change where that pointer points at.

Answer 5

Why not typecasting. The following code will print 6.

int main()
{
    int x = 5;
    const int* c{ &x};
    int* p{( int*) c};
    *p = 6;
    std::cout << x << std::endl;
}