wie sage ich dem Compiler, dass ich ein Objekt "deklarieren"(das heist dann bestimmt nicht mehr deklarieren, deswegen in Anführungseichen) ohne es zu erstellen.

Der Code

Klasse meinObjekt;

erzeugt ja gleich das Objekt. Ich möchte es aber ggf. erst später mit new erzeugen.

extern Type object;

Ad aCTa schrieb:

Normalerweise (ohne Heap):

extern Type object;

Das geht aber nur auf globaler Ebene, definiert werden muss das Objekt dennoch.

> definiert werden muss das Objekt dennoch.

Das ist ja der Zweck der Deklaration.

Normalerweise (ohne Heap):

extern Type object;

Ich bezweifle, dass er das gesucht hat. Zuerst dachte ich auch, dass er extern sucht, aber da er ja noch gesagt hat, dass er es mit new erzeugen will ist der Fall wohl klar.

> definiert werden muss das Objekt dennoch.
Das ist ja der Zweck der Deklaration.

Nein, der Definition.

Ich meinte nur, dass extern im Zusammenhang mit verspäteter Initialisierung zur Laufzeit nicht viel bringt, sondern nur die Speicherklasse (bzw. eine explizite Deklaration ohne Definition auf Namensraum-Ebene) kennzeichnet.

int main()
{
    MyClass* obj = NULL;
    // ...
    // später:
    if (condition)
        obj = new MyClass;
    // ...
    delete obj;
}

int main()
{
    extern MyClass obj;
    // ...
    // später:
    ??? // wie jetzt?
}

Aber man sollte die Initialisierung ohnehin nicht unnötig hinauszögern. Lieber die Variablen erst deklarieren, wenn sie benötigt werden.

hier bekommt man ja schnell eine Antwort. Das ich geschrieben habe, dass ich es mit new erzeugen will war blöd, denn das impliziert ja Zeiger.

Das es mit Zeigern geht ist mir klar. Ich frage mich nur, ob das spätere erzeugen auch ohne geht.

Wie man vl schon gemerkt hat, lerne ich gerade erst C++, vormals habe ich jahrelang mit Delphi programmiert, wo das mit dem späteren erzeugen ohne Zeiger möglich war.

Wie man vl schon gemerkt hat, lerne ich gerade erst C++, vormals habe ich jahrelang mit Delphi programmiert, wo das mit dem späteren erzeugen ohne Zeiger möglich war.

Der Delphi Code

var
  myObject : myClass;
begin
  myObject := myClass.Create;
  // ...
  myObject.Free;
end;

entspricht einem C++ Code

{
  myClass * myObject = new MyClass;
  // ...
  delete myObject;
}

Das von dir gepostete

Klasse meinObjekt;

existiert in Delphi gar nicht. Du kannst Dir auch eine Referenz auf dein Objekt holen ( myClass& ref = *myObject ), wenn Du die Zeigersemantik nicht gebrauchen kannst.

Ich frage mich nur, ob das spätere erzeugen auch ohne geht.

Nicht ohne einige Akrobatik.

Der Delphi Code

var
  myObject : myClass;
begin
  myObject := myClass.Create;
  // ...
  myObject.Free;
end;

entspricht einem C++ Code

{
  myClass * myObject = new MyClass;
  // ...
  delete myObject;
}

Hmmm... das sieht ja komisch aus. Das Delphi, was ich kenne (ist schon eine Weile her) verwendet keine implizite Indirektion, so wie Du es andeutest. Da hat man noch mit New und Dispose gearbeitet (ähnlich wie new und delete in C++) und explizit Zeiger gebaut ( type PMyClass = ^TMyClass; ). Ist das so richtig, wie Du es gesagt hast? Dann wäre das ja eine Änderung der Sprache, die nicht abwärtskompatibel ist, oder?

kk

(* pseudo-delphi *)
var
  meinObjekt : meineKlasse;
begin
  bla bla;
  meinObjekt.Create;
  blub blub;
end;

// c++
{
  bla bla;
  meineKlasse meinObjekt;
  blub blub;
}