Why only integral or enum type can be initialised in a C++ class?

Question

I don't understand why C++ allows only integral types and enum (enum is an integral type too) to be defined within a class declaration. Whereas all other types, including float point types (i.e. double and float), have to be defined outside the class declaration. Clearly the must be a reason for this, but I can't figure it out.

Code example:

#include <iostream>

using namespace std;

struct Node {

  static const int c = 0;  // Legal Definition 
  static const long l = 0l; // Legal Definition 
  static const short s = 0; // Legal Definition 

  static const float f = 0.0f; // Illegal definition 
  static const string S = "Test"; // Illegal definition 

  static const string JOB_TYPE; // Legal declaration
  static const float f; // Legal declaration 
  static const double d; // Legal declaration 
};

const string Node::JOB_TYPE = "Test"; // correct definition
const float Node::f = 0.0f;  // correct definition 
const double Node::d = 0.0;  // correct definition 

int main() {

  cout << Node::c << endl;
  cout << Node::c << endl;

  cout << Node::JOB_TYPE << endl;

  cout << Node::f << endl;

}

You will just have problem if you put the `Node` struct in a header and you include it in 2 files. — Pierre Emmanuel Lallemant, Jan 17 '16 at 14:16
This is a very good question - Got my brain cells ratting this Sunday. Thanks — Ed Heal, Jan 17 '16 at 14:17
Peculiar rules for floating-point are usually because of concerns about cross-compilers, that is, compilers that run on one system but generate code for another. It's easy enough to deal with integral types that match the target system; getting the details of another system's floating-point types is much more complicated. — Pete Becker, Jan 17 '16 at 14:18
@PierreEmmanuelLallemant I don't have any problem with the code in itself. I just want to understand the reason behind this design choice. — Giuseppe Pes, Jan 17 '16 at 14:18
Those types, when declared as `const` and initialized with a constant expression, can be used in contexts where a compile-time constant is required. Therefore, C++11 has extended this for static members declared as `constexpr`. Note that the in-class initialization *is not a definition of the object*, it merely provides a value but not the storage. — dyp, Jan 17 '16 at 14:25
Related/dup: http://stackoverflow.com/q/16373831/ and http://stackoverflow.com/a/9657064/ — dyp, Jan 17 '16 at 14:26

Mats Petersson · Accepted Answer · 2016-01-17T15:15:15.937

The key reason here is that integral types (and enum because inside the compiler these become integers of some sort) can be trivially replaced and used directly as constants.

In other words, struct S { static const int x = 42;}, if the compiler sees S::x, it can immediately replace it with the constant 42 in the generated code. The same does not (always) apply to float, and certainly not for constructor-dependent types such as std::string - the compiler can not allocate memory for std::string without calling new (or std::string::allocator). So, for constants that have to be "constructed" and/or have more complex criteria for how they can be used (think of a processor that doesn't have hardware support for floating point - function calls to load and store floating point values, etc), the language can not dictate that it should be allowed to do that.

If you include the struct Node declaration with static const std::string S = "test";, how many places should the compiler store Node::S in? Which one should it use, when it finally links your three translation units into one program - or should it use different ones? What happens then if you const_cast the Node::S and modify it? The latter is assuming you have an environment where this doesn't cause a crash, which is entirely plausible, and whilst that is undefined behaviour, I'm not sure the compiler should make it as weird as using different values in each translation unit in that case...

Edit: As mentioned in the comments, C++11 does allow further types to be used in a similar way, so the restrictions are being relaxed as compiler and hardware technology is being improved. I doubt you'll ever be able to static const std::map<X, Y> a = { ... } tho', as that is a rather complex data-type to construct...

"The key reason here is that integral types (and enum because inside the compiler these become integers of some sort) can be trivially replaced and used directly as constants. " More generally, literal types can be used this way -- maybe we can hope that the rule will be relaxed to include these? — Chris Beck, Jan 17 '16 at 14:48
Well, the problem is that literals may also be floating point values [not sure if there are others too], and they often require special treatment - particularly on hardware that hasn't got built-in support for floating point. — Mats Petersson, Jan 17 '16 at 14:52
@ChrisBeck "will be relaxed" -> "are relaxed". http://melpon.org/wandbox/permlink/1qxlfeqKMVWoeti7 and more generally, all literal types, [class.static.data]p3 — dyp, Jan 17 '16 at 14:57

score 0 · Answer 2 · answered Jan 17 '16 at 14:39

0

Initialising of std::string requires some code to be executed in run time.

Initialising a pointer with string literal requires placing the string somewhere in the memory, also in run time.

answered Jan 17 '16 at 14:39

Kyrylo Polezhaiev

1,626
11
18

Why only integral or enum type can be initialised in a C++ class?

2 Answers2