Objekt "deklarieren" ohne zu erstellen?

[Ad aCTa]

> definiert werden muss das Objekt dennoch.

Das ist ja der Zweck der Deklaration.

[drakon]

Ad aCTa schrieb:

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.

[Nexus]

Ad aCTa schrieb:

> 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.

[mousepad]

Hallo,

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.

[Nexus]

Bevor hier noch weiter spekuliert wird, solltest du (mousepad) vielleicht einen konkreten Anwendungsfall beschreiben, in dem du eine verzögerte Initialisierung für sinnvoll hältst. Am besten mit ein wenig Code. Je nach Kontext gibt es nämlich andere Möglichkeiten.

[brotbernd]

mousepad schrieb:

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.

[hustbaer]

mousepad schrieb:

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

Nicht ohne einige Akrobatik.

[krümelkacker]

brotbernd schrieb:

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

[brotbernd]

Ich muss erst seit kurzem mit Delphi arbeiten. Habe da aber auch mit einem uraltem Delphi5 angefangen (Hab dann aber schnell dafür gesorgt, dass eine aktuelle Version angeschafft wird )
Aber auch in der 5er Version war das der Weg Objekte zu erzeugen (und zwar der einzige mir bekannte, was mich anfangs ziemlich geärgert hat, naja eigentlich immer noch). Jede Klasse die von TObject erbt, erbt dessen constructor Create und destructor Destroy bzw. überschreibt/überlädt diesen.

[Don06]

New und Dispose in Delphi werden noch unterstützt, kommen allerdings noch aus Turbo Pascal. Sie sind also schon relativ alt.

[Bashar]

Kann es sein, dass man den expliziten Konstruktoraufruf in Delphi nur braucht, weil die Variablen in einem eigenen Deklarationsteil vor dem Block deklariert werden? In C++ erstellt man Variablen genau an der Stelle, wo man sie braucht.

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

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