如何在C ++中声明不可变类（Java示例）

Question

How can I do this in C++?

//java example
public class MyImmutable {
     private final int numToBeInitializedOnConstructionOrCompilationError;

     public MyImmutable(int n) {
         this.numToBeInitializedOnConstructionOrCompilationError = n;
     }
}

With Java if the final property is not initialized when declared or on the constructor the compiler will error out, this code works since the member variable is initialized in the constructor. How can I enforce immutability in a class declaration in C++?

(defining only public getter methods is not an acceptable answer, I know 'const' must be part of the solution)

If I do this in C++:

class MyImmutable 
{
  private:
     const int numToBeInitializedOnConstruction;

  public:
     MyImmutable(int n);
};

MyImmutable::MyImmutable(int n) 
{
  numToBeInitializedOnConstruction = n;
}

I get the following errors, basically telling me I cannot assign the const member, so I guess const is way more strict than java's 'final', is there another keyword or is there a way to initialize a const after it's been declared?

$ gcc const.cc 
const.cc:10:10: error: constructor for 'MyClass' must explicitly initialize the const member
      'numToBeInitializedOnConstruction'
MyClass::MyClass(int n) {
         ^
const.cc:3:13: note: declared here
  const int numToBeInitializedOnConstruction;
            ^
const.cc:11:36: error: read-only variable is not assignable
  numToBeInitializedOnConstruction = n;
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^
2 errors generated.

so how do I declare the equivalent of a java final member variable in C++? is this possible?

Answer 1

C++ can handle object immutability in a much nicer fashion than in Java. First of all, you can make an immutable object out of nearly any type with the const qualifier.

const string str = "asd";
const MyClass myObj(1);

You can also have constant attributes like that numToBeInitializedOnConstruction you have, but it must be initialized in the constructor's member initialization list, like this:

MyImmutable::MyImmutable(int n)
 : numToBeInitializedOnConstruction(n) // like this
{
}

Answer 2

Use initialization list like:

MyImmutable::MyImmutable(int n): numToBeInitializedOnConstruction(n) {}

EDIT: Just a better indent.

Answer 3

To declare an immutable object , simply declare it as const :

const Foo myImmutableFoo;

To declare immutable attributes of a class, you can declare those members const -- but you weren't using the correct syntax to initialize them. Given:

class Foo
{ 
  const int mImmutableN;
public:
  Foo();
}; 

You cant initialize mImmutableN in the body of the constructor; it must be initialized in the constructor's initialization list:

Foo::Foo()
:
  mImmutableFoo (42)
{
}