Const Correctnessfrage

Hallo!

ich habe folgende Klasse:

class Manager
		{
			public:
				Manager(){ pTyp1 = new Typ; };
				return Typ* GetTyp1(); { return(pTyp1) };

			private:
				Typ *pTyp1;
		}

Jetzt wird ja eine Kopie des Pointers pTyp1 zurückgeliefert, wie bekomme ich es hin das man damit nur die Methoden des Objects auf das pTyp1 zeigt aufrufen kann?
Es soll also nicht folgendes gehen:

delete manager.GetTyp1();

oder

Typ *neuerPointer = manager.GetTyp1();

sondern nur

manger.GetTyp1()->//Methode

Wie bekomme ich das hin?

spjoe

Einfach void als rückgabe wert nehemn bin mir nicht ganz sicher was du meinst mit

Typ *neuerPointer = manager.GetTyp1();

nicht gehen sollst meinst. Wenn dur nur wisssen willst ob type vorhaden is oder nicht nimm bool

Ich denke nicht das mir das weiter hilft.

Zu

Typ* GetTyp1(); { return(pTyp1) };

(das return war selbstverständlich ein Tippfehler":

Ich will nicht wissen ob er vorhanden ist, ich will nicht das er "zweckentfremdet" wird, d.h. nur der destruktor der Klasse Manager soll ihn deleten dürfen, niemand von außen.
D.h. auch das die Kopie vom Pointer nicht einfach einem neuen Pointer zugewiesen werden darf

Typ *neuerPointer = manager.GetTyp1();

rüdiger

return Typ* GetTyp1(); { return(pTyp1) };

Syntax Fehler

Wenn du das wirklich vermeiden willst, dann bau dir ein kleines Temp-Objekt

class foo {
  template<typename T>
  class funcaller {
    T *obj;
  public:
    typedef T value_type;

    funcaller(value_type *o) : obj(o) { }

    value_type *operator->() { return obj; }
  };
  bar obj;
  //...
public:
  funcaller<bar> get() { return funcaller<bar>(obj); }
  //...
};

Hmm ich dachte das könnte ich jetzt irgendwie mit const lösen?
Ich hatte verschiedene Dinge ausprobiert, aber alles hat nicht so funktioniert wie ich es wollte.

class Manager
        {
            public:
                Manager(){ pTyp1 = new Typ; };
                Typ* GetTyp1(); { return(pTyp1) };

            private:
                Typ *pTyp1;
        }

Hab ich keine Chance das jetzt per const zu verhindern?
Falls nein, ist denn diese Methode ansonsten const correct? Ich zweifel nämlich irgendwie daran

simon.phoenix

const schrieb:

Hmm ich dachte das könnte ich jetzt irgendwie mit const lösen?
Ich hatte verschiedene Dinge ausprobiert, aber alles hat nicht so funktioniert wie ich es wollte.
class Manager
        {
            public:
                Manager(){ pTyp1 = new Typ; };
                Typ* GetTyp1(); { return(pTyp1) };

            private:
                Typ *pTyp1;
        }
Hab ich keine Chance das jetzt per const zu verhindern?
Falls nein, ist denn diese Methode ansonsten const correct? Ich zweifel nämlich irgendwie daran

Vielleicht so?

class Manager
        {
            public:
                Manager() : typ1_(new Typ) {}
                ~Manager() { delete typ1_; } // Nicht vergessen!
                const Typ* GetTyp1() const { return typ1_; }

            private:
                Typ* typ1_;
        };

simon.phoenix

@kingruedi:

Es sieht aus als bräuchte er eine relativ simple Lösung und als wäre er nocht nicht so der C++-Gott. Dann gleich operator->-Überladen + Template vorschlagen?

rüdiger

Anders kann man das eben nicht machen.

Wobei der normale Weg aussreichen sollte. Wenn jemand wirklich delete foo.get(); macht, dann soll er nicht erwarten, dass das Programm danach noch weiter läuft

simon.phoenix

kingruedi schrieb:

Anders kann man das eben nicht machen.

Wobei der normale Weg aussreichen sollte. Wenn jemand wirklich delete foo.get(); macht, dann soll er nicht erwarten, dass das Programm danach noch weiter läuft

Ja da hast du recht. Ich verstehe sowieso nicht, warum man immer von einem total verblödeten Client-Code-Programmierer ausgeht

Das ich kein C++ Gott bin mag wahr sein, trotzdem verstehe ich die Lösung von kingruedi.

Ich wollte das Arbeiten mit meiner Klasse halt Idiotensicher machen, aber dieser im Verhältnis relativ große Aufwand ist mir das dann doch nicht wert.

Wenn dann eben jemand meint delete instanz.GetTyp1() machen zu müssen hat er dann eben ein Problem.

ness

Theoretisch kann man jeden ponter deleten den man in die Finger bekommt... Aber wer das macht ist wohl selber Schuld...