Can someone tell me the difference between these two versions of a declaration of a structure?
struct S
{
uint8_t a;
};
and
const struct S
{
uint8_t a;
}
Followed by:
void main(void)
{
struct S s = {1};
s.a++;
}
Hint, i've tried both versions for S in Visual Studio C++ 2010 Express so I know that both compile with errors.
Is the "const struct" doing nothing at all? "const struct S s = {1};" certainly does, but that's not the issue at the moment.
Regards
Rich
/********************************************/
I've just worked out what
const struct <typename> <{type}> <variable instances a, b, .., z>;
is doing:
When const is present before the "struct", all variable instances are const, as though they'd be defined with:
const struct <typename> a, b, z;
So it does do something, but not when there's no instance definitions in-line with the struct declaration.
Rich
A declaration of structure just defines the data type.
const qualifier appies to a variable not a data type. So adding const preceeding a struct declaration should be redundant at the most.
With:
const struct S
{
uint8_t a;
};
The const qualifier there is nonsense, and may even cause a compilation error with some C compilers. gcc issues a warning.
The intent appears to be to declare the data type struct S. In this case, the proper syntax is:
struct S
{
uint8_t a;
};
const struct S
{
uint8_t a;
};
is not a valid construct.
This
const struct S
{
uint8_t a;
} x;
could possibly be valid as you're declaring a variable x that is now const, meaning it cannot change.
The const qualifier applies to variables or members.
To instantiate a const variable, just specify const during instantiation.
What const does, is:
during compilation, verify that only reads are performed on the const variables
if the const variable is created with a value which can be resolved during compilation, put the variable in the program memory
When const is applied to members, like in:
struct T {
int const i;
int j;
};
You can only (legally) assign the value i during the creation of the structure.
You may be able to modify a const value (if the program memory sits in RAM and not ROM) by casting it to a non-const type (const-cast) but this is something you shouldn't do.
The typical usage of const-cast is when you use a library which does not specify the constness in function declarations, and your code does. At this point if you want to use it you have to trust it and cast parameters before calling its functions.
It is nonsense to use const keyword before struct.
If you are using gcc compiler, it shows you the following warning:
warning: useless type qualifier in empty declaration [enabled by default]
This is the only use I can think of:
const struct S {
int a;
int b;
} s;
This declares a struct and immediately creates an instance for it named s and at this point, a and b in s are initialized to 0 (please note that at this point s is a global variable in the translation unit which it has been declared in and can be externally linked to).
printf("a = %d\t b = %d\n", s.a, s.b); // a = 0 b = 0
If you try to set members of s, you will fail:
s.a = 1; //error: assignment of member ‘a’ in read-only object
So, s is not really useful here...unless you do something like:
const struct S {
int a;
int b;
} s = { 1, 2 };
Now let's create another instance of the same struct (declaration is still same as above):
struct S other;
other.a = 1;
other.b = 2;
printf("a = %d\t b = %d\n", other.a, other.b); // a = 1 b = 2
The compiler will not complain anymore as other is not const! only s is const!
Now, what that const do, you may ask? let's try to change s:
s = other; // error: assignment of read-only variable ‘s’
That is all to it. If you did not need the compiler to allocate storage for s at the point of declaration and still needed an instance of s to be const you would just add const at the point of instantiating struct S (note the capital S!!)
Bonus 1
const struct S {
int a;
int b;
};
note that there is no small s anymore. At this point, GCC will warn you that const qualifier does not do anything!!!!
Bonus 2
If you want every instance of the struct to be const, that is its members can only be initialized at the point of definition you can do like (using typedef):
typedef const struct S {
int a;
int b;
} s;
// The wrong way
s thisIsAnS;
thisIsAnS.a = 1; //error: assignment of member ‘a’ in read-only object
// The correct way
s thisIsAnS = { 1 , 2 }; //compiles fine, but you can not change a or b anymore
Conclusion
To me, this is just syntactic sugar and only adds unnecessary complexity to the code. But who am I to judge...
When you declare
const var;
then it allocate the some memory space for it but
struct var;
it was just an declaration compiler does not allocate any space for it.
so it shows the error and in const struct you didn't declare any varible see the code so it shows error.
Related
I like to create scenarios in my code where I declare a static global struct inside a .c file that everyone will share, it contains configuration stuff. Right underneath the declaration, I'll create a constant pointer to this struct and put this in the .h file so that everyone can get access to it.
Sometimes, within a .c file, I like to have a global pointer to the specific configuration that that .c file cares about, that way I don't have constantly keep referencing the global struct, because sometimes I'll get this configuration from a different source on different projects.
The issue that I have is that I can't define this "local global" pointer because the initializer element is not constant. Here is an example.
typedef struct
{
int Value;
} mystruct_t, *pmystruct_t;
static const mystruct_t GlobalStruct;
const pmystruct_t pGlobalStruct = &GlobalStruct;
const int *ValuePtr = &pGlobalStruct->Value;
int main()
{
*ValuePtr = 10;
return 0;
}
I tried reading on the const keywords for pointer in C, and I thought I understood it, but apparently it's still a mystery to me. The line of code that I tried, and may gotten me closer to that piece of code to compile is
const mystruct_t const *pGlobalStruct = &GlobalStruct;
However, it still doesn't compile because ValuePtr initializer element is not constant (the error I get).
The end goal here is to have ValuePtr be a constant, where no one can change where it is pointing to, but allow change the elements of the struct that it is pointing to.
EDIT: I want ValuePtr to use pGlobalStruct
The definition
const pmystruct_t pGlobalStruct = &GlobalStruct;
makes the variable (the pointer itself) pGlobalStruct constant, not the structure that it points to.
This is only one of the many flaws that hiding pointers behind type-aliases have.
And to make the definition of ValuePtr valid as well, then you need to make both the pointer variable as well as the structure it points to constant:
const mystruct_t * const pGlobalStruct = &GlobalStruct;
Now pGlobalStruct is a constant pointer to a constant mystruct_t object.
Do not hide pointers behind the typedefs.
If your pointer is referencing constant object you cant assign it with the value. You can only initialize the object.
const int x = 10; //initialization
cosnt int *ptr = &x;
How do I get a const pointer to a const struct?
All possible combinations below:
struct str
{
int x;
float b;
};
struct str a;
const struct str b;
const struct str *c;
struct str * const d;
const struct str * const e;
a - not const structure
b - const structure
c - not const pointer to const structure
d - const pointer to not const structure
e - const pointer to const structure
In your case
const mystruct_t * const pGlobalSttruct = &GlobalStruct;
In .h file
typedef enum
{A1,A2}struct_A;
typedef struct
{const struct_A G;} struct_B;
typedef struct
{const struct_B * F;} struct_C;
typedef struct
{const struct_C *E;} struct_D;
In .c file
const struct_D temp;
How to set/change value of:
temp->E[i].F[0].G
The only way to set value to const structure is to initialize it while declaring it. So,the solution would be:
struct_B B = {A1};
struct_C C = {&B};
struct_D temp = {&C};
However, I haven't come across any scenario where such nested const structures would be required.
At first: If we see something qualified as const we should take it seriously and avoid to cast away the constness. If you cast away the const qualifier of global or static data then you get undefined behavior and you are going to get a segmentation fault in linux.
In general, the correct way is the one pointed by Suven Pandey in the other answer.
However, there are valid cases to cast away const. Your case may qualify as as one of the exceptions in https://wiki.sei.cmu.edu/confluence/display/c/EXP05-C.+Do+not+cast+away+a+const+qualification
EXP05-C-EX3: Because const means "read-only," and not "constant," it is sometimes useful to declare struct members as (pointer to) const objects to obtain diagnostics when the user tries to change them in some way other than via the functions that are specifically designed to maintain that data type. Within those functions, however, it may be necessary to strip off the const qualification to update those members.
We can cast away const when your data is in a mutable region of memory like the stack or heap. We need to be careful, anyway, as that is likely to produce unexpected behavior if the code relays on that data being immutable and we change it.
So, this is what you asked for:
typedef enum {A1, A2} enum_A;
typedef struct { const enum_A G; } struct_B;
typedef struct { const struct_B * F; } struct_C;
typedef struct { const struct_C *E; } struct_D;
int main() {
const struct_B b = {A1};
const struct_C c = {&b};
const struct_D temp = {&c};
enum_A *pointer_to_non_const_A = &temp.E[0].F[0].G;
*pointer_to_non_const_A = A2;
}
But that depends on where temp is defined and is going to cause compilation warning. If temp is a global that is going to crash. Here are the cases when it works, but shall not be used, and when it crashes:
#include <stdlib.h>
const int global_in_data_segment = 0;
int main() {
const int in_stack = 0;
static const int static_in_data_segment = 0;
const int *in_heap = malloc(sizeof(int));
int *works;
works = &in_stack; *works = 1;
works = in_heap; *works = 2;
int *crashes;
crashes = &global_in_data_segment; *crashes = 3;
crashes = &static_in_data_segment; *crashes = 4;
}
For completeness, c++ has const_cast: https://en.cppreference.com/w/cpp/language/const_cast
I am programming a module on a microcontoller for interfacing it's EEPROM to receive some user data from there. Since you can not overwrite the EEPROM easily I want to return a const pointer to const data.
Now my functions prototype looks like this:
const struct userData const* getEEPROMDataAtIndex(uint32_t uidIndex)
while gcc tells me duplicate 'const' declaration specifier [-Wduplicate-decl-specifier]. Shouldn't each const I use have a different effect? One to make the pointed-to data immutable, the other for the received pointer not to be retarged?
You have declared your struct const twice. Since it doesn't make sense to make the pointer const in a return type, just remove one of the const declarations. If you wanted to make the pointer const (which doesn't really make sense in a return type) you would put const after the asterisk.
You seems have some miss understanding about const, for example.
#include <stdio.h>
int main()
{
int a=123, b=456;
const int *pa = &a;
pa = &b; //legal
*pa = 4; //illegal
printf("a=%d\n", a);
return 0;
}
gcc will give an error saying that
x.c: In function ‘main’:
x.c:8:9: error: assignment of read-only location ‘*pa’
*pa = 4;
^
for your purpose, if I understand correctly, you should define the function as
const struct userData * getEEPROMDataAtIndex(uint32_t uidIndex);
//this const declare the returned pointer point to something cannot be changed
then when you initiate your constant pointer by call this function
const struct userData * const myp = getEEPROMDataAtIndex(index);
// ^ this declare the pointer itself (myp) cannot be changed
Hope this helps.
const struct userData const* => const struct userData *const
It can be used during the initilalisation of the automatic variable:
const struct userData * const foo(void);
void bar(void)
{
const struct userData *const ptr_to_something = foo();
/* some code */
}
I suggest using typdef to type define your return data type. Then in the function declaration you only need to declare the return type as the typedef name.
For example...
typedef struct USER_DATA
{
....
...
};
I think it would simplify things a bit.
what happens if you interchange 'const struct' ... to 'struct const'?
When I declare structure given below, it is throwing compilation error.
typedef struct{
const char x; //it is throwing compilation error
const char y;
}A;
void main()
{
A *a1;
a1 = (A*)malloc(2);
}
How can I make structure's field (characters x and y) as constant?
That should be fine, but of course you can't assign to them, only use initialization.
So it doesn't make a lot of sense to allocate an instance on the heap.
This works:
#include <stdio.h>
int main(void) {
typedef struct {
const int x, y;
} A;
A my_a = { 12, 13 };
printf("x=%d\ny=%d\n", my_a.x, my_a.y);
return 0;
}
It prints:
x=12
y=13
Also, please don't cast the return value of malloc() in C.
First, you should use malloc to allocate the size of the struct, not a magic number 2. Also, don't cast malloc return value, it is automatically promoted to the compatible pointer type.
a1 = malloc(sizeof(A));
Second, there isn't really not much use to make struct member const.
A *a1;
a1 = malloc(sizeof(A));
a1's members are not initialized to any state here, yet the compiler forbidden any assignments to them, since it is defined as const, so a1->x = 'a'; won't compile.
A a2;
a2->x = 'a'; // won't compile too
The only valid use case is:
A a3 = {'a', 'b'};
You can't.
With POO in C you can disable the modification of those fields, if you:
define getters: char A_get_x(A *p); and char A_get_y(A *p);
define the struct in the .c to hide its implementation
only write typedef struct A A; in the .h file, to allow to use that type.
define a constructor : A *A_new(); which returns A with the values desired on x and y.
By doing this, you can only modify the values in the constructor, and after the object is created the values wont change (if you dont force the values with pointers etc..)
I am trying to access structure element via constant pointer. Program works like it should but I got warning 'intialization from incompatible pointer type' and '(near initalization for 'B.settings)'. I don't really know how to correctly initalize it. Can someone pls help me figure that out?
Here's my code :
It's just a snippet of larger part. Idea is to have access to structure variables x,y when moving via pointers to const structure. Hope that make sense.
#include <stdio.h>
#define PGM_STR(X) ((const char[]) { X })
struct SettingsStruct
{
unsigned int x;
unsigned int y;
}Settings;
struct constitem
{
const char * const text;
const struct constitem *next;
const struct SettingsStruct * settings;
};
struct constitem const A;
struct constitem const B = {PGM_STR("x"), &A, &Settings.x };
struct constitem const A = {PGM_STR("y"), &B, &Settings.y };
static const struct constitem *currMenuPtr=&A;
void main()
{
Settings.x = 1;
Settings.y = 2;
printf("%s\n",currMenuPtr->text);
printf("%d\n",*(currMenuPtr->settings));
currMenuPtr = currMenuPtr->next;
printf("%s\n",currMenuPtr->text);
printf("%d\n",*(currMenuPtr->settings));
}
In your code, Settings.x is an unsigned int, and therefore &Settings.x is an unsigned int *. You are trying to use it to initialize a value of type const struct SettingsStruct *. The compiler is quite right to complain -- what you are doing is highly questionable, and I suppose probably not what you actually mean to do. The same applies to Settings.y.
It looks like you could get the compiler to stop complaining (about that) by changing the type of the third element of struct constitem to unsigned int *. You'll have to judge whether that actually works for you in the larger scheme of your program, though.
There is also a problem with using &A in the initializer for variable B when A is not yet declared at the point where the initializer appears. Inasmuch as you also refer to B in A's initializer, you can't solve that by swapping the declaration order. If you really do want a circular chain of pointers, then the pointer values cannot be const, because at least one of them will need to be modified after initialization.