static member variable file scope

Question

Static variable has the scope inside that file only where they are been declared, as shown in below code:

file1-

static int a;

file2-

extern int a;

This will give linking error as static variable a has the scope in file1 only. But I am confused with below code:

file2-

#include "file1"
extern int a;

Here it would not give any linking error. Then it means compiler is refering "a" which is declared in file1. But when you debug you will find address of variable "a" is different in file1 and file2. Is the compiler creating a another global variable "a" in file2?

complete code-

file temp1.h -

static int w = 9;

class temp1 
{
public:
   temp1(void);
public:
   ~temp1(void);

   void func();

};

........................cpp.................

temp1::temp1(void)
{
   int e =w;
}

temp1::~temp1(void)
{
}
void temp1::func()
{
}

....................................... file2-

#include "temp1.h"

extern int w;
int _tmain(int argc, _TCHAR* argv[])
{
   w  = 12;

   temp1 obj;
   return 0;
}

here when i debug and check the value and adrress in temp1 constructor and in file2 is different.

Unless temp1.h is including itself, that code isn't complete (or possibly isn't correct). Can you show the contents of temp1.h? — Lara Bailey
– Lara Bailey, Commented Jun 5, 2011 at 14:03
Post edit, I think my answer fully answers your question. In both translation units w has internal linkage due to the first declaration of w being the static int w = 9; declaration included from the header file. This mean that both translation units have their own distinct independent w. — Lara Bailey
– Lara Bailey, Commented Jun 5, 2011 at 14:35
So it means second translation unit also define the variable w even it was extern (as it would not cause redefinition because first definition was internal linkage in translation unit 1)? — G Mann
– G Mann, Commented Jun 5, 2011 at 15:13
Yes, a declaration of an object marked extern without an initializer is never a definition. If the object has previously been declared then the linkage is taken from the previous declaration (in this case internal), if no previous declaration exist then the object has external linkage. The only definition in both translation units comes from the static declaration in the header file. — Lara Bailey
– Lara Bailey, Commented Jun 5, 2011 at 17:06

Oliver Charlesworth · Accepted Answer · 2011-06-05 13:04:12Z

7

static and extern are not to do with files, they're to do with translation units. Remember that when you #include something, the preprocessor is effectively doing a copy-and-paste. static, etc. refer to the result of that process, which is a translation unit.

So in your second example, there is only one translation unit. So there is only one variable a. [But note, doing it this way is considered very bad style.]

answered Jun 5, 2011 at 13:04

Oliver Charlesworth

274k34 gold badges591 silver badges687 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

G Mann Over a year ago

yes, this is one translation unit. but why address of varaibale "a" is different in both files?

Oliver Charlesworth Over a year ago

@Ghanshyam: I think you'd have to edit your question to show a complete, compilable example to show what you mean.

Oliver Charlesworth Over a year ago

@Ghanshyam: That has nothing to do with the address of variables. Please edit you original question with some code!

Lara Bailey · Accepted Answer · 2011-06-05 13:35:12Z

file1:

static int a;

file2:

extern int a;

There are two variables referenced here. The first is a declaration and definition of a variable with internal linkage in file1; the second is a declaration only of a variable with external linkage in file2. This doesn't necessarily cause an error; it is completely legal to have a variable with external linkage used in some translation units and identically named variables with internal linkage used by other translation units. Any link error would only occur if a is used in file2 and there isn't a definition for this a in file2 or any other translation unit in the program.

#include "file1"
extern int a;

In this example you have combined the two files into a single translation unit. The variable a is first declared and defined in file with internal linkage due to static, the second is just a re-declaration which doesn't alter the previous linkage. The second declaration is redundant in this instance. If you are still compiling both files separately as well as including file1 from file2 then each translation unit (file1 and file1 + file2) will have its own distinct variable called a.

Note that if you had used extern int a; followed by static int a; then this would be a compile error as the first declaration would declare a to have external linkage if no previously declaration was visible and then the second declaration and definition would cause an error because the linkage implied by static int a; would conflict with the previous declaration.

Now this make sense for me. Thanks Charles for clarification.

Collectives™ on Stack Overflow

static member variable file scope

2 Answers 2

3 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related