CODEWITHSUNDEEP
c++constants
Nim
Nim

Reputation: 33655

declaring a const instance of a class

Let's say I have a class defined as follows:

class foo{};

now, this is perfectly acceptable;

foo f;

how come this is a compiler error? (uninitialized const ‘f’)

const foo f;

Why do we have to do this?

const foo f = foo();

I know why we can't do this..

const foo f(); // though it compiles..

Interestingly, the following is valid:

const std::string f;

So what is missing from foo?

I realize that there are three questions there and it's bad form, but I'm hoping someone can clear this up for me in one answer.

EDIT: please feel free to close it if it's stupid...

Upvotes: 40

Views: 8882

Answers (4)

Konrad Rudolph
Konrad Rudolph

Reputation: 546133

Your class is a POD (essentially because it doesn’t provide a default constructor). POD variables are not initialized upon declaration. That is, this:

foo x;

does not initialize x to a meaningful value. This has to be done separately. Now, when you declare it as const, this may never happen because you cannot assign to or change x any more.

Consider the equivalence to int:

int x; // legal
const int y; // illegal

As you have noticed, using std::string instead of foo compiles. That’s because std::string is not a POD. A simple solution to your dilemma is to provide a default constructor for foo:

class foo {
public:
    foo() { }
};

Now your const foo x; code compiles.

Upvotes: 48

Öö Tiib
Öö Tiib

Reputation: 11031

I think there are more alternatives. You can do

const foo f={};

or

const foo f(());

Const means you can not assign to it later, so you have to initialize it. Since you did not define default constructor the compiler assumes it has to be initialized by you. std::string has default constructor so it is called implicitly by compiler.

Upvotes: 1

Johannes Schaub - litb
Johannes Schaub - litb

Reputation: 507393

Raising an error in the situation of an empty class is a known problem, and reported as issue #253.

Upvotes: 6

user197015
user197015

Reputation:

const, applied to a simple plain-old-data variable, indicates that that variable will not change in that context - so you aren't going to be able to reassign it to something. Therefore, you must initialize it or it will be perpetually uninitialized and thus useless.

Upvotes: 1

Related Questions