why volatile can repeat declare?-CodePudding

#include <stdio.h>

volatile int isInit_STD;

volatile int isInit_STD;
 
int main() {
        printf("v-%d-addr%x\n",isInit_STD,&isInit_STD);
        isInit_STD = 1;
        printf("v-%d-addr%x\n",isInit_STD,&isInit_STD);
        return 0;
}

and the result is:

v-0-addr387fd040
v-1-addr387fd040

why volatile can repeat declare?

It turns out they are all the same, the same address.

If one of them deletes the 'volatile', that can't be compiled success.

I want to know the reason, looking forward to your reply.

CodePudding user response：

The C standard says that (C17 6.7/4)

All declarations in the same scope that refer to the same object or function shall specify compatible types.

That means that as long as you use the same name, same type and same type qualifiers (volatile etc), you can declare the variable as many times as you like, and it will all refer to the same object.

And the opposite: if you use different types or qualifiers, but give the variable the same name, it is a constraint violation and the compiler must issue a diagnostic message.

Apart from what standard C allows, common sense states that we should avoid having multiple declarations of the same variable when possible. Good program design practices also state that we should avoid declaring objects at file scope, or if that's not possible, avoid using external linkage ("globals") and instead enforce interal linkage by declaring the variable static.

CodePudding user response：

I want to know the reason

You can repeat a declaration of anything as many times as you want, as long as the declarations are "the same". It's not specific to volatile, just there has to be no conflict. All declarations refer to the same thing.

The following is an actual whole .c file:

// 3 declarations of function main.
int main();
int main();
int main();

// 3 declarations of struct A type.
struct A;
struct A;
struct A;

// 3 declarations of variable a
extern volatile int a;
extern volatile int a;
extern volatile int a;

// 3 declarations of variable b
int b;
int b;
int b;

// 3 declarations of variable c
volatile int c;
volatile int c;
volatile int c;

// example with conflicts:
int d;
// volatile int d; // error - conflict with above, d is not volatile
// static int d;   // error - conflict with above, d is not static
extern int d; // Fine! Stuff declared at file scope is implicitly extern.