Ich finde es irritierend, dass ich nicht konstante Funktionen eines Objekts aufrufen kann, wenn ich einen Zeiger auf dieses Objekt habe. Ich kann nicht zulassen, dass der Zeiger ein const-Zeiger ist, da ich auch Nicht-const-Funktionen aufrufen muss. Daher scheint meine einzige Option static_casts auszuführen, um sicherzustellen, dass die Konstanz auch über Zeiger hinweg funktioniert. Hier ist ein minimales Beispiel:

class MyClassImpl
{
  MyClassImpl(void) : m_i(0) {}

  int increment(void) {
    ++m_i;
    return m_i;
  }

  private:
    int m_i;
};

class MyClass
{
  MyClass(void) : m_pImpl(new MyClassImpl()){}

  ~MyClass(void) {
    delete m_pImpl;
  }

  int doNothing(void) const {
    m_pImpl->increment(); // works although MyClassImpl::increment() is non-const
    // static_cast<const MyClassImpl *>(m_pImpl)->increment(); // this will not compile because of non-constness
  }


  private:
  MyClass(const MyClass & rhs);
  MyClassImpl * m_pImpl;
};

Allerdings frage ich mich, ob der static_cast zur Laufzeit irgendwelche Kosten hat. Werden static_casts zum Zeitpunkt der Kompilierung vollständig ausgewertet, oder entsteht ein gewisser Overhead, sofern doNothing () häufig aufgerufen wird.

Bearbeiten: Meine Frage unterscheidet sich von C ++ static_cast Laufzeitaufwand weil in meinem Fall der static_cast nur const hinzufügt. Andere Benutzer, die diese Frage finden, sind möglicherweise an der genannten Frage interessiert.