C++ Force const-ness of lvalue in initializer expression

Question

I would like the compiler to enforce const-ness of an lvalue (non-reference) but don't know if this is possible in C++. An example:

int foo() { return 5; }

int main() {
  // Is there anything I can add to the declaration of foo()
  // that would make the following cause a compile-error?
  int a = foo();

  // Whereas this compiles fine.
  const int a = foo();
}

Answer 1

This is not really possible with something like an int because you need to give access to read the int and if they can read the int then they can copy it into a non-const int.

But from your comments it sounds like what you have in reality is not an int but a more complex user defined type, some sort of container perhaps. You can easily create an immutable container. This container could be a wrapper, or alternative implementation of your existing container. It then doesn't matter if the caller uses a const or non-const variable it is still immutable.

class MyClass {
  std::vector<int> data;
public:
  MyClass(size_t size) : data(size) {}
  int& operator[](size_t index) { return data[index]; }
  int operator[](size_t index) const { return data[index]; }
  size_t size() const { return data.size(); }
};

class MyClassImmutable {
  MyClass mc;
public:
  MyClassImmutable(MyClass&& mc) : mc(std::move(mc)){}
  int operator[](size_t index) const { return mc[index]; }
  size_t size() const { return mc.size(); }
  const MyClass& get() const { return mc; }
};

MyClassImmutable foo() {
  MyClass mc(100);
  mc[10] = 3;
  return mc;
}

void func(const MyClass& mc);

int main() {
    MyClassImmutable mci = foo();
    std::cout << mci[10] << "\n";  // Can read individual values
    //mci[10] = 4; // Error immutable
    func(mc.get());  // call function taking a const MyClass&
}

Live demo.

Of course there is nothing to stop the caller from copying each and every value from your immutable container and inserting them into a mutable container.

Edit: An alternative approach might be to return a smart pointer-to-const. The only downside is you have to pay for a dynamic memory allocation:

std::unique_ptr<const MyClass> foo() {
  auto mc = std::make_unique<MyClass>(100);
  (*mc)[10] = 3;
  return mc;
}

void func(const MyClass& mc);

int main() {
    auto mc = foo();
    std::cout << (*mc)[10] << "\n";  // Can read individual values
    //(*mc)[10] = 4; // Error const
    func(*mc);  // can pass to a function taking a const MyClass&
}