C ++变量extern声明

Question

I have declared some constants in a header file:

extern int  g_iShortSize1FrameEncoded=30;
extern int  g_iByteSize1FrameEncoded=(g_iShortSize1FrameEncoded*2);
extern int  g_iShortSize1FrameDecoded=960;
extern int  g_iByteSize1FrameDecoded=(g_iShortSize1FrameDecoded*2);

This is really convenient for me because I need to use these "constants" in various apps and change them often, and I want to do this only once so that I don't forget to change anything.

It compiles fine.

However my declaration is a bit "wild".

I have to trust the compiler will compile it in the right way.

Is my approach fine anyway?

I will not change these values at runtime, only during development.

I have 3 different applications, and all consume / need these values.

In the applications I simply wanted to include them as

#include "..\..\myconstants.h"

Answer 1

No, it's not fine, and they are not constants. By initialising an extern variable in its declaration, the declaration becomes a definition. Since it has external linkage, it must obey the One Definition Rule and be defined just once; but yours will be defined wherever the header is included.

If they are constants, then make them so, with internal linkage:

const int  g_iShortSize1FrameEncoded=30;
^^^^^

On the other hand you say you need to "change them often". If you mean they actually change at runtime (rather than changing them by editing the initialiser and recompiling), then they can't be constants; instead, you'll need to declare them in the header and define them in exactly one source file:

// declarations in header
extern int g_iShortSize1FrameEncoded; // no initialiser

// definitions in source file
int g_iShortSize1FrameEncoded = 30;

In either case, the variables will be initialised in the order of their definitions; so as long as no value depends on a later variable's value, they will get the expected values.

Answer 2

Usually you'd just put this in header file:

extern const int  g_iShortSize1FrameEncoded;
extern const int  g_iByteSize1FrameEncoded;
extern const int  g_iShortSize1FrameDecoded;
extern const int  g_iByteSize1FrameDecoded;

and this in .cpp file corresponding to that header:

const int  g_iShortSize1FrameEncoded=30;
const int  g_iByteSize1FrameEncoded=(g_iShortSize1FrameEncoded*2);
const int  g_iShortSize1FrameDecoded=960;
const int  g_iByteSize1FrameDecoded=(g_iShortSize1FrameDecoded*2);

This way linker knows that variables are placed in one compilation unit and refers to them from other compilation units. Also note the const keyword -- you wrote that they are constants.

Answer 3

This kind of global variables is usually used like this:

some_header.h:

#ifndef SOME_HEADER_FILE_INCLUDED
#define SOME_HEADER_FILE_INCLUDED

extern int  g_iShortSize1FrameEncoded;
extern int  g_iByteSize1FrameEncoded;
extern int  g_iShortSize1FrameDecoded;
extern int  g_iByteSize1FrameDecoded;

#endif

main.cpp:

#include "some_header.h"

int g_iShortSize1FrameEncoded = 30;
int g_iByteSize1FrameEncoded = (g_iShortSize1FrameEncoded * 2);
int g_iShortSize1FrameDecoded = 960;
int g_iByteSize1FrameDecoded = (g_iShortSize1FrameDecoded * 2);

void another(void);

int main(int argc, char **argv)
{
   another();
   return 0;
}

another.cpp:

#include "some_header.h"

void another(void)
{
    g_iShortSize1FrameEncoded = 50;
}