Re: extern variables
Comp1597@yahoo.co.uk wrote:
For example, I ran the following program:
// Code below in a source file
#include "SomeHeader.h"
#include <iostream>
int main ()
{
int j = doropi;
std::cout << j;
}
//Code in SomeHeader.h
const int doropi = 9;
The result of the program was that 9 was output. However, what I
expected was a compile error based on the rule (or what I thought was
the rule) that const definitions have file scope
There's never been such a rule. The scope of an identifier depends on
the point and the manner of its declaration. It is not tied in any way
to the declaration's being a "const definition" or not.
I don't see why you'd expect a compiler error in your case. You put the
declaration if 'doropi' in an include file and then #include-d it into
your source file before the first use (in 'main'). No problems here.
and that the way to
use consts from other files was via extern.
There is not such thing as "other files" in C++. There's such things as
other _translation_ _units_. In your example you have one and only one
translation unit. So the issue of "using consts from other files
(meaning - other translation units)" simply does not arise here at all.
If you really had to refer to a constant defined in another translation
unit, you'd indeed have to use 'extern'.
My code had no extern and yet I was able to use the const anyway.
Yes. Because you declare, define and use it in the same one translation
unit.
This made me question the whole purpose of externs. I didn't need the
extern to fetch a member from another file and yet I thought that was
exactly what extern is for.
One can say that 'extern' in a non-defining declaration is used for
"fetching" (or "linking to") entities defined in other translation
units. You don't have other translation units in your example, so there
can possibly be any need for such an 'extern' in it.
What I'd be grateful for is a very simple example of a necessary use
of extern variables. Googling gave me lots of definitions but no
examples.
Create a program with _two_ translation units, i.e. _two_ source files.
Put a definition of a variable in one source file:
int variable = 5;
then go to another source file and "fetch" that variable there using
'extern':
#include <iostream>
extern int variable;
int main ()
{
std::cout << variable << std::endl;
}
--
Best regards,
Andrey Tarasevich