Providing const access to base class

I have many classes derived from a single base class. The derived classes
have extra class invariants which they have to maintain, so I am blocking
using of base class mutable operations by using protected inheritance.
However, const operations would be OK, especially passing the objects to
functions expecting const references to the base class. How could
something like this be achieved? It appears conversion operators do not
help. I have many such classes and many functions, so overloading the
functions for each type seems counter-productive. And I want to keep the
calling code as simple as possible.

The following code fails with: test.cpp(52): error C2243: 'type cast' :
conversion from 'B *' to 'const A &' exists, but is inaccessible

TIA
Paavo

#include <assert.h>
#include <iostream>

struct A {
    A(): k_(0) {}
    void Mutate(int k) {
        k_ = k;
    }
    int Get() const {
        return k_;
    }
private:
    int k_;
};

struct B: protected A {
    B() {
        A::Mutate(1);
    }
    void CheckClassInvariant() const {
        assert(Get()%2==1);
    }
    // inherit const access operations
    using A::Get;
    // override mutable operations
    void Mutate(int k) {
        A::Mutate(k - k%2 + 1);
    }
    // It seems this does not help
    operator const A& () const {return *this;}
    // neither this (slicing would be fine by me).
    operator A() const {return *this;}
};

// mutable operation on A
void f(A& a) {
    a.Mutate(10);
}

// const operation on A
void g(const A& a) {
    std::cout << a.Get() << "\n";
}

int main() {
    A a;
    B b;
    f(a);
    // f(b); // not compiling, good!
    b.CheckClassInvariant();
    g(a);
    g(b); // not compiling, bad!
}