ich habe folgenden Code:

void Mngr::renderPatches(const Camera& cam) const {
   for(int i=0; i < sharedPatchData->visiblePatches.size(); i++)
      sharedPatchData->visiblePatches[i]->render(cam);
}

sharedPatchData ist vom Typ SharedPatchData*. visiblePatches ist vom Typ Patch** und render() ist NICHT const!
Was ich nicht verstehe: Wieso kann ich aus einer const Methode (renderPatches) eine NICHT const Methode (render) aufrufen?

Was ich nicht verstehe: Wieso kann ich aus einer const Methode (renderPatches) eine NICHT const Methode (render) aufrufen?

Weil visiblePatches[i] in jedem Fall ein Zeiger auf nicht-const ist. Innerhalb einer const-Elementfunktion sind nur die "direkten" Objektmitglieder const -- sofern sie nicht mit mutable deklariert worden sind.

class foo {
  int i;
  int& r;
  int* p;
public:
  foo(int& r, int* p) : i(42), r(r), p(p) {}
  void bar() const {
    ++i;  // NICHT erlaubt, i ist const
    ++p;  // NICHT erlaubt, p ist const
    ++r;  // OK
    ++*p; // OK
  }
};

Diese Regeln sind am sinnvollsten für die Mehrheit. Es gibt natürlich Fälle, in denen einem das "zuwenig const" ist. Beispiel: vector

struct int_vector {
  int* begin;
  int* end;
  int* capacity;
  .....
};

Da die Elemente logisch gesehen Bestandteile der Klasse sind, muss man hier Hand anlegen: Zugriff schützen und Elementfunktionen überladen:

struct int_vector {
private:
  int* begin;
  int* end;
  int* capacity;
public:
  int      & operator[](int index)       {return begin[index];}
  int const& operator[](int index) const {return begin[index];}
  .....
};

Beachte: begin[index] ist auch beim zweiten Mal nicht-const. Die Referenz wird bei der Rückgabe implizit zu einer ref-to-const konvertiert, siehe Rückgabetyp.

Gruß,
SP