LG

Soit une classe Y qui possède un membre de type classe X. L'objectif est que, si une méthode const de Y est appelée, il ne sera possible d'appeler que les méthodes const de X.

Soit la classe commune X :

#include <iostream>
 
struct X
{
  void g() const { std::cout << "g (const)\n"; }
  void g() { std::cout << "g (non-const)\n"; }
};

et le programme commun :

int main()
{
  Y y;
  y.f();
 
  const Y cy;
  cy.f();
}

struct Y
{
  Y() = default;
 
  void f() const
  {
    std::cout << "f (const)\n";
    m_ptrX.g();
  }
 
  void f()
  {
    std::cout << "f (non-const)\n";
    m_ptrX.g();
  }
 
  X m_ptrX;
};

Rendu :

f (non-const)
g (non-const)
f (const)
g (const)

struct Y
{
  Y() : m_ptrX(new X()) {};
 
  void f() const {
    std::cout << "f (const)\n";
    m_ptrX->g();
  }
 
  void f() {
    std::cout << "f (non-const)\n";
    m_ptrX->g();
  }
 
  X* m_ptrX;
};

Rendu :

f (non-const)
g (non-const)
f (const)
g (non-const)

struct Y
{
  Y() : m_ptrX(m_X) {};
 
  void f() const {
    std::cout << "f (const)\n";
    m_ptrX.g();
  }
 
  void f() {
    std::cout << "f (non-const)\n";
    m_ptrX.g();
  }
 
  X& m_ptrX;
  X m_X;
};

Rendu :

f (non-const)
g (non-const)
f (const)
g (non-const)

Fonctionne avec X*, std::unique_ptr et std::shared_ptr.

struct Y {
  Y() : m_ptrX(new X()) {};
 
  void f() const {
    std::cout << "f (const)\n";
    m_ptrX->g();
  }
 
  void f() {
    std::cout << "f (non-const)\n";
    m_ptrX->g();
  }
 
   std::experimental::propagate_const<X*> m_ptrX;
};

Rendu :

f (non-const)
g (non-const)
f (const)
g (const)

Impossible.