Thread: More questions about constants

Yes, but all modern linkers perform constant folding, merging these into one.

And as I said, one is a const expression, the other not. Observe:

Code:

const int CON1 = 5;
extern const int CON2;

template <int I>
class foo
{
};

int main()
{
	int ar_yes[CON1];
	int ar_no[CON2];

	foo<CON1> t_yes;
	foo<CON2> t_no;
}

Code:

$ g++ -c -pedantic -std=c++98 src.cpp
src.cpp: In function ‘int main()’:
src.cpp:12: error: ISO C++ forbids variable-size array ‘ar_no’
src.cpp:15: error: ‘CON2’ is not a valid template argument for type ‘int’ because it is a non-constant expression
src.cpp:15: error: invalid type in declaration before ‘;’ token

The -std and -pedantic arguments are necessary to disable GCC's VLA for C++ extension.

Originally Posted by R.Stiltskin

Code:

extern void print();

That's not necessary. You can remove the extern for function declarations.

The downside of having been taught not to use global variables is that I don't actually know how, but it seems that the only way to make a single (non-const) variable x global and accessible to all files is by using extern. Is this correct?

Yes, that is correct.

...if I understand you correctly, the linker will merge multiple copies of a constant into one if they all have the same value, which they will. (Clearly, this does not happen when each file defines the same const symbol with a different value.)
Do you agree?

No, this is not always the case. Ponder the following output:

Address of n is Help.cpp: 0040225C
Address of n in Help2.cpp: 0040223C

From this simple code:

Code:

// Help.h
const int n = 10;

// Help.cpp
#include "Help.h"
int main()
{
	cout << "Address of n is Help.cpp: " << &n << endl;
	Help();
}

// Help2.cpp
#include "Help.h"
void Help()
{
	cout << "Address of n in Help2.cpp: " << &n << endl;
}

So clearly, as you see, there are two variables with the same number, even in release.
Same goes even if it's static.
Same with an unnamed namespace.

Originally Posted by Elysia

No, this is not always the case. Ponder the following output:


From this simple code:

Code:

// Help.h
const int n = 10;

// Help.cpp
#include "Help.h"
int main()
{
	cout << "Address of n is Help.cpp: " << &n << endl;
	Help();
}

// Help2.cpp
#include "Help.h"
void Help()
{
	cout << "Address of n in Help2.cpp: " << &n << endl;
}

So clearly, as you see, there are two variables with the same number, even in release.
Same goes even if it's static.
Same with an unnamed namespace.

Have you considered that the very act of taking the address could be what is preventing the folding from occurring? Given that the address is the only observable difference between the constants, taking it would make the folding observable, and thus prevent it from occurring. Just a thought.

Very quantum.

I don't see how you got that to run without <iostream> and std:: for cout & endl, but with those modifications, yes, g++ 4.1.2 also ends up with 2 different addresses for n, so this seems to contradict CornedBee's statement.

Here is the only way that I have found so far that produces a single global constant (a single address) defined in a separate file:

Code:

// Help.h
extern const int n;

// Help.cpp
#include "Help.h"
#include <iostream>

void Help();

int main()
{
  std::cout << "Address of n is Help.cpp: " << &n << std::endl;
  Help();
}

// Help2.cpp
#include "Help.h"
#include <iostream>

void Help()
{
  std::cout << "Address of n in Help2.cpp: " << &n << std::endl;
}


//Help3.cpp
// this file can contain all constant definitions

#include "Help.h"

const int n = 10;

ed: I didn't see CornedBee's last post until after I posted this one. Re the "quantum" comment, it's an interesting thought, but what are we to make of that? i.e. How can one rely on a compiler to behave a certain way, when attempting to verify it results in different behavior? In short, do you recommend following the approach I stated in the last paragraph of #17?

How can one rely on a compiler to behave a certain way, when attempting to verify it results in different behavior?

Suppose that CornedBee says is true (and it might be). Does silently folding the constants affect the behaviour of the code? No, it does not, so it is safe. Only when it is unsafe then it is not done, so it does not matter when it is safe.

Another thought: constant folding is done by the compiler, not the linker, right?

In this case it would be performed by the linker, if it is done at all. Other types of constant folding (e.g., evaluating constant arithmetic expressions or substituting constant expressions) would be done by the compiler.

Originally Posted by R.Stiltskin

i.e. How can one rely on a compiler to behave a certain way, when attempting to verify it results in different behavior?

It is perfectly well-defined behavior. "const" tells the compiler it is allowed to fold the constant when possible. If it is declared "extern," it cannot fold the constant because it has been explicitly declared to reside elsewhere. And if you take the address of a constant, this also forces the compiler to create an actual variable so that it can have an address.

The change in semantics of "const" in C++ was meant to DISCOURAGE the use of #define. You were supposed to be able to replace a #define with a const declaration, even in a header file. In other words, the "new const" was meant to act very much like a #define replacement. The examples given here show that declaring a global/namespace const variable in a header file is usually okay, because we don't typically take the address of a simple constant or use "extern."

Maybe it's confusing, but the comparison with quantum physics was meant partially in jest (I assume) -- there's no random behavior here, you just have to understand it.

I guess the bottom line is that simply creating a constant variable in a header is generally the best option, there is no need for extern, static or an unnamed namespace.

I agree, since it appears that the extern version is a minor optimisation that may already be done by the linker.

Originally Posted by R.Stiltskin

I don't see how you got that to run without <iostream> and std:: for cout & endl, but with those modifications, yes, g++ 4.1.2 also ends up with 2 different addresses for n, so this seems to contradict CornedBee's statement.

I left that out.
The "real" code would be, for Help2.cpp:

Code:

#include "stdafx.h"
//#include <Stuff/NewThread.h>
#include "Help.h"

using namespace std;

void Help()
{
	cout << "Address of n in Help2.cpp: " << &n << endl;
}

Originally Posted by CornedBee

Have you considered that the very act of taking the address could be what is preventing the folding from occurring? Given that the address is the only observable difference between the constants, taking it would make the folding observable, and thus prevent it from occurring. Just a thought.

Very quantum.

Then what do you propose to find out if there's one or multiple constant variables?
Even with assembly, there will still be two copies.