Differentiating between const references to immutable vs. mutable objects

I don't know the reason, but here's how you can do it:

struct C {
   template<typename T, typename T2>
   C(T&&, const T2&&) = delete;

   C(const Params&, const DataBuffer&) { /*...*/ }
};

By declaring a constructor that takes any argument by non-const reference, it will always be a better match than the constructor taking const&, as a cv-qualifier doesn't have to be added.

The const& constructor is a better match when passing a const parameters, as the cv-qualifier doesn't have to be removed.

DataBuffer db;

const Params cp;
C c{ cp, db }; // ok, second constructor call is chosen

Params p;
C c2{ p, db }; // error, constructor is deleted

Due note that, as @IgorTandetnik said, you can break your requirement easily:

Params pa;
const Params& ref_pa = pa;
C c3{ ref_pa, db }; // ok, but shouldn't compile.

As previous answers, C++ doesn't have the concept of "immutable". @Rakete1111 gave you the answer I would have used. However, Visual Studio will put global const variable in .rdata segment, where other variables will go to .data. The .rdata segment will generate a fault when trying to write.

If you need a run time test whether an object is read only, use a signal handler, like this:

#include <csignal>
const int l_ci = 42;
int l_i = 43;

class AV {};
void segv_handler(int signal) {
    throw AV{};
}

template <typename T>
bool is_mutable(const T& t)
{
    T* pt = const_cast<int*>(&t);

    try {
        *pt = T();
    }
    catch (AV av) {
        return false;
    }

    return true;
}

void test_const()
{
    auto prev_handler = std::signal(SIGSEGV, segv_handler);
    is_mutable(l_i);
    is_mutable(l_ci);
}

What you need is not a const reference, but a const object. Value semantics solve your problem. Nobody can modify a const object. While a reference is only const where it is marked const, because the referenced object may not be const. Take that for example :

int a;

int const& b = a;

// b = 4; <-- not compiling, the reference is const

// (1)

At (1), a is int, and b is a reference to const int. While a is not const, the language permit the reference to const to be bound on a non const object. So it's a reference to const object that is bound to a mutable object. The type system won't allow you to modify the mutable object through the reference, because it may have been bound to a const object. In our case it isn't, but the tribe don't change. However, even declaration of a reference to const won't change the original declaration. The int a is still a mutable object. I can replace the comment (1) by this:

a = 7;

This is valid, whenever reference or other variables have been declared. A mutable int can change, and nothing can prevent it from changing. Heck, even another program like cheat engine can change the value of a mutable variable. Even if you had rules in the language to guarantee that it won't be modified, there is nothing they will prevent the mutable variable from changing values. In any language. In machine language, a mutable value is permitted to change. However, maybe some API of the operating system can help you change the mutability of memory regions.

What can you do to solve this problem now?

If you want to be 100% sure an object won't be modified, you must have immutable data. You usually declare immutable objects with the const keyword :

const int a = 8;

int const& b = a;

// a cannot change, and b is guaranteed to be equal to 8 at this point.

If you don't want a to be immutable and still guarantee b to not change, use values instead of references :

int a = 8;

const int b = a;

a = 9;

// The value of b is still 8, and is guaranteed to not change.

Here, value sematic can help you have what you want.

Then const reference are there for what? There are there to express what you are going to do with the reference, and help enforce what can change where.

As the question has been further clarified, no there is no way to determine if the reference has been bound to a mutable or immutable object in the first place. There is, however, some tricks you can have to differentiate the mutability.

You see, if you want more information about the mutability to be passed along with the instance, you can store that information in the type.

template<typename T, bool mut>
struct maybe_immutable : T {
    using T::T;
    static constexpr auto mutable = mut;
};

// v--- you must sync them --v
const maybe_immutable<int, false> obj;

This is the most simple way to implement it, but a naive one too. The contained data will be conditionally immutable, but it forces you to sync template parameter and constness. However, the solution allows you to do this :

template<typename T>
void do_something(const T& object) {
    if(object.mutable) {
        // initially mutable
    } else {
        // initially const
    }
}

I hope I understand you question correct it is not as explicit as so to say "D language" but with const r-value references you can make immutable parameters.

What I understand from immutable is forexample

void foo ( const int&&  immutableVar );
foo(4);-> is ok 
int a = 5;
foo(a);->is not ok