I have two source files that need to access a common variable. What is the best way to do this? e.g.:
source1.cpp:
int global;
int function();
int main()
{
global=42;
function();
return 0;
}
source2.cpp:
int function()
{
if(global==42)
return 42;
return 0;
}
Should the declaration of the variable global be static, extern, or should it be in a header file included by both files, etc?
The global variable should be declared extern in a header file included by both source files, and then defined in only one of those source files:
common.h
extern int global;
source1.cpp
#include "common.h"
int global;
int function();
int main()
{
global=42;
function();
return 0;
}
source2.cpp
#include "common.h"
int function()
{
if(global==42)
return 42;
return 0;
}
You add a "header file", that describes the interface to module source1.cpp:
source1.h
#ifndef SOURCE1_H_
#define SOURCE1_H_
extern int global;
#endif
source2.h
#ifndef SOURCE2_H_
#define SOURCE2_H_
int function();
#endif
and add an #include statement in each file, that uses this variable, and (important) that defines the variable.
source1.cpp
#include "source1.h"
#include "source2.h"
int global;
int main()
{
global=42;
function();
return 0;
}
source2.cpp
#include "source1.h"
#include "source2.h"
int function()
{
if(global==42)
return 42;
return 0;
}
While it is not necessary, I suggest the name source1.h for the file to show that it describes the public interface to the module source1.cpp. In the same way source2.h describes what is public available in source2.cpp.
In one file you declare it as in source1.cpp, in the second you declare it as
extern int global;
Of course you really don't want to be doing this and should probably post a question about what you are trying to achieve so people here can give you other ways of achieving it.
Related
I have two source files that need to access a common variable. What is the best way to do this? e.g.:
source1.cpp:
int global;
int function();
int main()
{
global=42;
function();
return 0;
}
source2.cpp:
int function()
{
if(global==42)
return 42;
return 0;
}
Should the declaration of the variable global be static, extern, or should it be in a header file included by both files, etc?
The global variable should be declared extern in a header file included by both source files, and then defined in only one of those source files:
common.h
extern int global;
source1.cpp
#include "common.h"
int global;
int function();
int main()
{
global=42;
function();
return 0;
}
source2.cpp
#include "common.h"
int function()
{
if(global==42)
return 42;
return 0;
}
You add a "header file", that describes the interface to module source1.cpp:
source1.h
#ifndef SOURCE1_H_
#define SOURCE1_H_
extern int global;
#endif
source2.h
#ifndef SOURCE2_H_
#define SOURCE2_H_
int function();
#endif
and add an #include statement in each file, that uses this variable, and (important) that defines the variable.
source1.cpp
#include "source1.h"
#include "source2.h"
int global;
int main()
{
global=42;
function();
return 0;
}
source2.cpp
#include "source1.h"
#include "source2.h"
int function()
{
if(global==42)
return 42;
return 0;
}
While it is not necessary, I suggest the name source1.h for the file to show that it describes the public interface to the module source1.cpp. In the same way source2.h describes what is public available in source2.cpp.
In one file you declare it as in source1.cpp, in the second you declare it as
extern int global;
Of course you really don't want to be doing this and should probably post a question about what you are trying to achieve so people here can give you other ways of achieving it.
I have two source files that need to access a common variable. What is the best way to do this? e.g.:
source1.cpp:
int global;
int function();
int main()
{
global=42;
function();
return 0;
}
source2.cpp:
int function()
{
if(global==42)
return 42;
return 0;
}
Should the declaration of the variable global be static, extern, or should it be in a header file included by both files, etc?
The global variable should be declared extern in a header file included by both source files, and then defined in only one of those source files:
common.h
extern int global;
source1.cpp
#include "common.h"
int global;
int function();
int main()
{
global=42;
function();
return 0;
}
source2.cpp
#include "common.h"
int function()
{
if(global==42)
return 42;
return 0;
}
You add a "header file", that describes the interface to module source1.cpp:
source1.h
#ifndef SOURCE1_H_
#define SOURCE1_H_
extern int global;
#endif
source2.h
#ifndef SOURCE2_H_
#define SOURCE2_H_
int function();
#endif
and add an #include statement in each file, that uses this variable, and (important) that defines the variable.
source1.cpp
#include "source1.h"
#include "source2.h"
int global;
int main()
{
global=42;
function();
return 0;
}
source2.cpp
#include "source1.h"
#include "source2.h"
int function()
{
if(global==42)
return 42;
return 0;
}
While it is not necessary, I suggest the name source1.h for the file to show that it describes the public interface to the module source1.cpp. In the same way source2.h describes what is public available in source2.cpp.
In one file you declare it as in source1.cpp, in the second you declare it as
extern int global;
Of course you really don't want to be doing this and should probably post a question about what you are trying to achieve so people here can give you other ways of achieving it.
Consider this code.
//header.h
int x;
//otherSource.cpp
#include "header.h"
//main.cpp
#include "header.h"
...
int main()
{
}
In this case compiler erred with the message. "fatal error LNK1169: one or more multiply defined symbols found"
but when I add static before x, it compiles without errors.
And here is the second case.
//header.h
class A
{
public:
void f(){}
static int a;
};
int A::a = 0;
/otherSource.cpp
#include "header.h"
//main.cpp
#include "header.h"
...
int main()
{
}
In this case compiler again erred with multiple declaration.
Can anybody explain me the behavior we static variables in classes and in global declarations?? Thanks in advance.
The issue with the static member variable is that you have the definition occur in the header file. If you #include the file in multiple source files, you have multiple definitions of the static member variable.
To fix this, the header file should consist only of this:
#ifndef HEADER_H
#define HEADER_H
// In the header file
class A
{
public:
void f(){}
static int a;
};
#endif
The definition of the static variable a should be in one and only one module. The obvious place for this is in your main.cpp.
#include "header.h"
int A::a = 0; // defined here
int main()
{
}
Declare x as extern in header.h to tell the compiler that x will be defined somewhere else:
extern int x;
Then define x once in the source file which you think is most fitting.
For example in otherSource.cpp:
int x = some_initial_value;
I have a header file that declares a class, and I want this class to access an integer that has been declared in the main cpp C++ file (i.e. another file than the class' one). I have been searching on Google and found nothing relevant. How can I do this?
To share a global variable among source files, use the extern keyword.
main.cpp
#include "foo.h"
int global_var=0;
int main()
{
foo();
return 0;
}
foo.h
#ifndef FOO_H
#define FOO_H
extern int global_var;
void foo();
#endif
foo.cpp
#include "foo.h"
int foo()
{
global_var=1;
}
Move the integer in main.cpp into a function, make it static there, have the function return a reference to it and put the function into a header file of its own which the class header file (or implementation file, if appropriate) includes.
integer.h:
#ifndef INTEGER_H // use some better, longer name here
#define INTEGER_H
int &Integer();
#endif
integer.cpp:
#include "integer.h"
int &Integer()
{
static int i = 0;
return i;
}
Access the integer like this:
int x = Integer(); // copy
Integer() = 123; // assign
I have two source files that need to access a common variable. What is the best way to do this? e.g.:
source1.cpp:
int global;
int function();
int main()
{
global=42;
function();
return 0;
}
source2.cpp:
int function()
{
if(global==42)
return 42;
return 0;
}
Should the declaration of the variable global be static, extern, or should it be in a header file included by both files, etc?
The global variable should be declared extern in a header file included by both source files, and then defined in only one of those source files:
common.h
extern int global;
source1.cpp
#include "common.h"
int global;
int function();
int main()
{
global=42;
function();
return 0;
}
source2.cpp
#include "common.h"
int function()
{
if(global==42)
return 42;
return 0;
}
You add a "header file", that describes the interface to module source1.cpp:
source1.h
#ifndef SOURCE1_H_
#define SOURCE1_H_
extern int global;
#endif
source2.h
#ifndef SOURCE2_H_
#define SOURCE2_H_
int function();
#endif
and add an #include statement in each file, that uses this variable, and (important) that defines the variable.
source1.cpp
#include "source1.h"
#include "source2.h"
int global;
int main()
{
global=42;
function();
return 0;
}
source2.cpp
#include "source1.h"
#include "source2.h"
int function()
{
if(global==42)
return 42;
return 0;
}
While it is not necessary, I suggest the name source1.h for the file to show that it describes the public interface to the module source1.cpp. In the same way source2.h describes what is public available in source2.cpp.
In one file you declare it as in source1.cpp, in the second you declare it as
extern int global;
Of course you really don't want to be doing this and should probably post a question about what you are trying to achieve so people here can give you other ways of achieving it.