What would be the utility of such a constructor? You can just initialize const objects with regular constructors. How are these objects not "true" const?

The specific use case I had in mind was a implicit “conversion” constructor that took an immutable object and gave back something that you couldn’t strip the const off of (it’d also take a mutable object and give you a normal thing back). What I have specifically is a class that provides a base set of operations and a subclass that lets you do some modifications, and what I am trying to do is wrap it in C++ with an object that is const depending on which class I am converting (converting object to const wrapper_class and mutable_object, a subclass of object, to just wrapper_class).

I don't fully grasp what you are trying to do here. This looks familiar though:

> What I have specifically is a class that provides a base set of operations and a subclass that lets you do some modifications

If you actually do this with public inheritance then you possibly break const correctness.

Having to separate types for the immutable and mutable data structures with appropriate conversions is a sound idea though.

> What I have specifically is a class that provides a base set of operations and a subclass that lets you do some modifications

Your object isn't actually immutable, it just doesn't let you directly mutate it. That's a really important distinction.

That's a common pattern. In C++, rather than using a subclass for the mutator, use a different (friend) class. The semantics for implicit conversion between two different classes will allow you to accomplish what you are asking for with enforcing no changes from one interface but not the other.

> In C++, rather than using a subclass for the mutator, use a different (friend) class.

Unfortunately I don't control this class :(

There are constexpr constructors

I'm looking for constructors that return immutable objects. Is there something in C++ that can help me?

Constructors do not return, and return type and lhs are decoupled, so you are looking for

    auto const &lol = make_wtf();

Well, more like I’m looking for something that gives you a const that you can’t get rid of. You could use a factory method but it’d be nicer if I could have a constructor that did it.

That's just not how C++ is designed. If you want const, you stick const on the member variables or declare member getter functions const. Then the language checks your work when you initialize an object into a constant variable.

This allows you to force an object to be immutable at a compiler enforced level regardless of how the calling code tries to initialize it.

Unfortunately I am trying to wrap const to something that wasn’t designed this way: https://news.ycombinator.com/item?id=20948523

Since soft const constraint is not part of the type, perhaps you could pass it to a lambda function that treats it as a const and another lambda function that treats it as mutable. A sort of const region and mutable region.