Originally posted by neotransotaku

---

try placing this as the first two lines of the shared header file

#ifdef __headerfile
#define __headerfile

and this as the end of the shared header file

#endif


usually this is the techinique to ensure a header file is included only once

---

Originally posted by Disch

---

If you define a variable to be global, it will have global scope (Global meaning it exists for the whole program). If you #include a header file which has a var declaration in several .cpp files, each .cpp file will create its own variable with the same name. This is where your problems are coming from.

The solution here is to make the variable once, then link it so that all .cpp files have access to it.


int myVar; /* will actually make the variable -- only have 1 of these */

extern int myVar; /* will not make the variable, will link to it after compile time -- have one of these for each .cpp file beyond the first */


Of course extern int myVar will only work if 'int myVar' is declared somewhere in your program.

For a halfway decent analogy of why it works this way... making the actual variable (int myVar) actaully makes the variable with a "body". Similar to how making a function with a body gives the function it's body. If you have a function in your program which has several bodies, you'll get errors much like the ones you were getting -- because you were making several different variables which have the same body -- and the compiler doesn't know which one you want to use.

Making it 'extern' says "okay, this variable exists... but not in this .cpp file, so we'll link to it, but it won't be in this compile" -- which is kind of like a body-less variable. Equivilent to having a function prototype (function without a body). It's making the function/var available for use, but without actually making it. Of course if you actually call the function, it will need to have a function body found at link time. Likewise if you actually use an extern var, it will need to find a var body at link time. Otherwise you get errors.


So yeah, only 1 cpp file has the variable. The others use 'extern' to link to that var. Yeah it's a pain in the ass -- which is one of the reasons why I avoid global vars like the plague.

EDIT:

To avoid a pain in the ass, you can sort of cheat with clever use of #defines

---

// your header file (referred to as "include.h" below)

#ifdef DO_NOT_MAKE_EXTERN
#define _EXTERN
#else
#define _EXTERN extern
#endif


_EXTERN int Var1;
_EXTERN int Var2;
//etc

---

// in **ONE** of your cpp files
#define DO_NOT_MAKE_EXTERNS
#include "include.h"

// rest of file here

---

// in all the other cpp files

#include "include.h" // note, no #define here

//rest of file here

---

Originally posted by Disch

---

Originally posted by beneficii

---

Okay, so I would have to add _EXTERN in front of every variable in the header file?

---

Yes. That will make it bodied or body-less depending on whether or not DO_NOT_MAKE_EXTERNS was defined before including the header.

---

Also, put in DO_NOT_MAKE_EXTERN and DO_NOT_MAKE_EXTERNS or was that a typo? Thanks.

---

sorry, that was a typo. It does matter what it is as long as it's the same thing both times. *me goes to edit post to correct that*

---

Originally posted by Disch

---

don't init the var when it's declared.

int myvar = 5; <--- don't do that, it won't like it when the var is extern

Instead init all your vars at program startup -- like call an Init() function or something which sets everything to what you want it to be.

---

Originally posted by Disch

---

If they're constant then declare them as constant and then you don't have to worry about that extern crap:

const int myArray[5] = {0,1,2,3,4};

that should work fine. If you still get problems (which I doubt), try making it static as well:

static const int myArray[5] = {0,1,2,3,4};

---

Originally posted by Kefka

---

Yea, actually, your opponent is dead not at 5, but at 13. So if you get them at 13, then you've won if you keep doing 3. However, I'm not gonna bother putting a spoiler tag on this, cause I'm sure everyone has read the other ones already.

There IS a way I have found to winning when taking a second turn... Play with that for a while, eh?

I bet people actually believe this and will try it now xD

---

Originally posted by Disch

---

Static variables maintain "normal" scope in the sense that if you declare them within a function, they can only be used inside that function. Or when declared in the class, they can only be used in the class (or by YourClass::varname).

However, if you're talking about when the variable is created/destroyed -- static variables have global scope in that sense -- they're created once on program startup and destroyed on program exit. They maintain their value through any function calls or any scope changes, as long as the running instance remains in tact.

For example:

---


int CountUp(void)
{
static int count = 0;
count++;
return count;
}


---

Calling that function will return 1 the first time it's called, then 2 the next time, then 3, and so on. Whereas if 'count' were non-static, you'd get 1 every time.


Static class member variables follow in the same vein. If you declare a static variable within a class, only one variable is created (regardless of the number of class objects created) and EVERY OBJECT of that class type will share that same variable. Likewise if the variable is public -- 'outsiders' to the class can access that variable with 'YourClassName::thevarname' -- you don't even need an object of the class to access it -- since it doesn't rely on any.

---

Originally posted by Disch

---

I just tried that code and got it to print 5. Don't know what to tell ya.

Any paticular reason why you need this var to be static anyway? I mean it's already global....

---

Originally posted by Kasumi-Astra

---

Discovery safely touched down in California about one and a half hours ago, in a perfect landing. The rest of the fleet is still indefinately grounded, although NASA has not officially declared Atlantis' next mission to be canceled. If the issue of debris falling from any part of the shuttle during lift-off can be solved, Atlantis is due to begin a mission in September. Discovery's next flight is due to begin in April 2006.

---