Static const variable is not constant in child class

Question

I am using Visual Studio 2008 and have two classes Parent and Child. Parent declares some static const variables in the header, which are then defined in the cpp file. When I try to use the defines as cases in a switch statement in a child class I get the error: C2051: case expression not constant. So I've done some testing and the behavior I'm seeing is somewhat inconsistent.

// Parent.h
class Parent
{
public:
    Parent();
    ~Parent(void) { }

  static const unsigned long A = 1;
  static const unsigned long B;
};


// Parent.cpp
#include "Parent.h"

const unsigned long Parent::B = 2;

Parent::Parent()
{
  // Everything works fine here
  unsigned long l;
  switch(l)
  {
  case A:
    break;
  case B:
    break;
  default:
    break;
  }
}

// Child.h
#pragma once
#include "Parent.h"

class Child :
  public Parent
{
public:
  Child(void);
  virtual ~Child(void) { }

  static const int C = 3;
  static const int D;
};

// Child.cpp
#include "Child.h"

const int Child::D = 4;

Child::Child(void)
{
  unsigned long l;
  switch(l)
  {
  case A:
    break;
  case B:  // C2051: case expression not constant
    break;
  case C:
    break;
  case D:
    break;
  default:
    break;
  }
}

I've also tried specifying Parent::B directly, which doesn't solve the issue. Is there some reason why the expression is constant in all cases except when the variable is inherited from a parent class?

James McNellis · Accepted Answer · 2011-03-24T16:41:38.470

7

You can only use a static const integer-type member variable in a constant expression if

it is initialized with a constant expression and
that constant expression is visible at the time that it is used.

In your switch, the value of Parent::A is visible because its initializer is in the Parent.h header file. The same goes for Child::C. The value of Child::D is visible because its initializer occurs earlier in Child.cpp.

However, the value of Parent::B is not visible: C++ source files are compiled separately, so when compiling Child.cpp, the compiler knows that Parent::B is a static const integer-type member variable, but it doesn't know what its value is. Thus, it can't be used in a constant expression in Child.cpp.

Note that if you ever use Parent::A as an object (e.g., &Parent::A), you will still need to define B in Parent.cpp, using const unsigned long Parent::A;, without an initializer, since you put the initializer in the class definition.

edited Mar 24 '11 at 16:41

answered Mar 24 '11 at 15:58

James McNellis

348,265
75
913
977

Please, what is the rationale for this? Seems weird since the constant value can be known at compilation time. – Antonio Pérez Mar 24 '11 at 16:07
@Antonio: I've updated my answer to try to explain: basically, it's because C++ source files are compiled independently. – James McNellis Mar 24 '11 at 16:11
@Antonio - If you compile child.cpp before writing parent.cpp, it is not known. – Bo Persson Mar 24 '11 at 16:12
Makes perfect sense now that I think about it. Thanks! – heavyd Mar 24 '11 at 16:16
@Rob: Sorry: I was overhauling the answer while you made that typo correction. Thanks for the correction, though! – James McNellis Mar 24 '11 at 16:18
1

More precisely, only if the initializer is visible. – James Kanze Mar 24 '11 at 16:28

score 0 · Answer 2 · answered Mar 24 '11 at 16:12

I am surprised that Visual Studio let you get away with declaring the const outside of a class declaration. The line

static const unsigned long B;

inside your Parent class should not be allowed. When I tried your example on the Mac, which uses GNU g++ compiler, I got the following error:

error: declaration of 'const long unsigned int Parent::B' outside of class is not definition

As for why it works on one class, but not the other; my guess: inside the child.cpp file, the compiler saw that D was indeed declared as a const, but it has no knowledge of how B was defined (or redefined). To make this work, you should move all constant declarations to the class in the .h file and not .cpp file.

That error message says that it’s about a declaration outside the class. — Davis Herring, Nov 21 '20 at 03:01

score 0 · Answer 3 · answered Mar 24 '11 at 16:14

The reason is that for the compiler the static const is not constant, beacuse at compile time it does not yet have a value, which is needed to compile the case statement.

The value is added later at link-time, when parent.o is linked to child.o (Remember that with plugins or shared libs link time could be as late as runtime).

Static const variable is not constant in child class

3 Answers3

Linked