Thread: More questions about constants

#define is the C version of a C++ constant. I would say the only time I would use #define is in a header file. I cannot find a reason why you would need to use it in a .cpp source file. constants more or less replaced #define in the C++ language when defining a variable to be constant ( read only ).

Every book I have read says #define on a variable is "evil" but that is their view not every single programmers. Just my two cents on the matter.

Originally Posted by R.Stiltskin

For example, in this thread
http://cboard.cprogramming.com/showt...ts+header+file
Elysia says "Don't put any variables in headers. Define them in a .cpp file and use extern in the header files."

The reason I mentioned that is because you'll get linking errors if you put variables in headers directly.
There may be several approaches to this, but what I'd do is use define in a header or make the constants in a .cpp file and declare them as extern in the header files.
That way you avoid linking errors.

Daved pointed out that "the use of the static keyword is deprecated when declaring objects in namespace scope", so that rules out ChaosEngine's suggestion. I note that the C++ Standard states in section 7.3.1.1: "The use of the static keyword is deprecated when declaring objects in a namespace scope (see annex D); the unnamed-namespace provides a superior alternative." This leads to Daved's suggestion, but I believe CornedBee is right: the unnamed/anonymous namespace means that there is a constant with the same name and value but in a different namespace in each file, thus it is duplicated across the program.

Consequently, I think that the use of extern as suggested by Elysia may be the best option, possibly when in a namespace. (At least excluding other options like enums and class members.)

Originally Posted by Daved

The question I still have is whether the extern is necessary for constants.

It seems not to be. Actually, I have no trouble getting it to work without extern, and I was also able to compile with extern const int j declared in a header and defined in the "main" source file. But I can't figure out how to compile with the constant declared as extern in a header and defined in a separate source file. This set of files gives me two "undefined reference to 'j'" errors. (It compiles all 3 ".o" files, but doesn't link them.) Can you tell me what's wrong?

Code:

#ed: commented out the following 2 lines as they were not serving any purpose in this makefile
#CXX = g++
#CCFLAGS = -g -Wall

scopetest:	source1.o	source2.o	constants.o
	g++	source1.o	source2.o	constants.o	-o scopetest

source1.o:	header1.h	header2.h	source1.cc
	g++	-c	source1.cc

source2.o:	header1.h	header2.h	source2.cc
	g++     -c	source2.cc

constants.o:	constants.cc
	g++	-c	constants.cc

clean:
	rm *.o scopetest

Code:

// header1.h

#ifndef header1_h
#define header1_h

static int i = 4;
extern const int j;
//const int j = 6;

int dosomething();

#endif

Code:

// header2.h

namespace {
const int c = 5;
}

Code:

// source1.cc

#include "header1.h"
#include "header2.h"
#include <iostream>
using namespace std;

//const int j = 6;

int main() {
  dosomething();
  ++i;
  dosomething();
  cout << "in main, i = " << i << endl;
  cout << "in main, c = " << c << endl;
  cout << "in main, j = " << j << endl;
  dosomething();

}

Code:

// source2.cc

#include "header1.h"
#include "header2.h"
#include <iostream>
using namespace std;

int dosomething() {
  cout << "in source2.cc, i = " << i << endl;
  cout << "in source2.cc, c = " << c << endl;
  cout << "in source2.cc, j = " << j << endl;
  return i;
}

Code:

// constants.cc

const int j = 6;

Code:

// a1.cc
#include <iostream>

const int x = 5;

int main()
{
   std::cout << x << std::endl;
}

Code:

// a2.cc
const int x = 6;

Compile and link these two together.

1) Does you compiler/linker allow it?
2) If so, what value does it print?
3) Explain.
4) Add a function to a2.cc which prints x, and call that from a1.cc. What happens?

This exercise should help you figure out how C++ treats "const" at global scope.

The reason I suggest not making the constant extern is related to what brewbuck just posted. Basically, if the compiler can't see the value of the constant, it will have to treat it as a variable as far as the generated code is concerned. It's still a constant, but it's no longer a "constant expression", as the C++ standard calls it. That's the case in Elysia's way.
By making the value visible, the compiler can use it directly, use it in template instantiations, in array sizes, put it as a literal in the code, do compile-time partial calculations, loop unrolling, dead code elimination and all that jazz.

E.g.

Code:

// hdr.hpp
#ifndef HDR_H_SR_H
#define HDR_H_SR_H

extern int CON1;
const int CON2 = 0;

#endif

// src.cpp
#include <iostream>
#include "hdr.hpp"

int main()
{
  if(CON1) {
    std::cout << "Con1\n";
  }
  if(CON2) {
    std::cout << "Con2\n";
  }
}

The CON2 branch is optimized away by the compiler, the CON1 branch isn't.

Originally Posted by CornedBee

Code:

// hdr.hpp
extern const int CON1;

How about extern const int. Regardless if it's in the current scope or not, the compiler can see that it's constant.

A typo in my test program. I just repeated it with the const, and the result is the same.
Of course, a compiler supporting whole-program optimization might discover this, too. Not all compilers do, though, and WPO is very expensive in compile time.

Nope. VC9 kills both for me. Even if it's "extern."

hmm... section 7.1.5.1 of the C++ Standard reads:

An object declared in namespace scope with a const-qualified type has internal linkage unless it is explicitly declared extern or unless it was previously declared to have external linkage. A variable of nonvolatile const-qualified integral or enumeration type initialized by an integral constant expression can be used in integral constant expressions (5.19).

This confirms what CornedBee is talking about concerning "all that jazz". What I find interesting though is the mention of "internal linkage". Since I am not very clear on this concept, I checked out section 3.5:

A program consists of one or more translation units (clause 2) linked together. A translation unit consists of a sequence of declarations.

Code:

translation-unit:
    declaration-seqopt

A name is said to have linkage when it might denote the same object, reference, function, type, template, namespace or value as a name introduced by a declaration in another scope:

• When a name has external linkage, the entity it denotes can be referred to by names from scopes of other translation units or from other scopes of the same translation unit.
• When a name has internal linkage, the entity it denotes can be referred to by names from other scopes in the same translation unit.
• When a name has no linkage, the entity it denotes cannot be referred to by names from other scopes.

A name having namespace scope (3.3.5) has internal linkage if it is the name of

• an object, reference, function or function template that is explicitly declared static or,
• an object or reference that is explicitly declared const and neither explicitly declared extern nor previously declared to have external linkage; or
• a data member of an anonymous union.

So, without the extern the constant has internal linkage. Doesn't this mean that we have the same scenario as with static or the unnamed namespace where each source file (or more precisely, translation unit) has its own copy of the constant?