Konstruktor ausführen wenn Klasse erzeugt werden soll

[Gehirnmann!]

hi,

ich hab echt ein übles Problem:
wenn ich eine klasse anlege, kann ich ja bekanntlich folgendes tun:

KlassenName myClass(X,Y,Z);

damit erzeuge ich eine klasse mit X,Y,Z als parameter an den konstruktor.
das war einfach!
jetzt aber mal so wie man es jeden tag braucht:
im header (einer klasse):

KlassenName myClass;

im sourcecode der selben klasse, irgendwo in einer funktion(.cpp)

myClass(X,Y,Z); // geht nicht
myClass = KLassenName(X,Y,Z); // geht nicht
KlassenName myClass(X,Y,Z);  // ist blödsinn, weil dann member der klasse 
                             // immer noch auf NULL zeigt.

wie soll man das denn da machen? bisher hab ich immer mit "new" meine klassen erzeugt, bei diesem projekt kann ich es mir leider net aussuchen!!

danke fuer jeden tipp
* the C++ rules-amount really su** *
marcello

[interpreter]

Und was ist jetzt die Frage? Was willst du eigentlich machen?
Und warum soll Zeile 2 nicht gehen und Zeile 3 Blödsinn sein?

[Gehirnmann!]

hi,
wenn ich das zweite mache, dann brauche ich was extra in meiner klasse:

...xxx.cpp(49): error C2582: 'operator =' function is unavailable in 'DialogRegionSetts'

Da ich aber die klasse net geschrieben hab, und auch net will (sehr gross), geht das net. Muss doch auch ohne "extras" gehen.

zu drittens:
ist doch klar: wenn ich das mache habe ich zwar local eine referenz, aber wenn ich aus der funktion springe, ist die klassenvariable so wie vorher. bringt doch nix.
ich will ja klassenweit zuweisen.. ich dachte das wird klar

marcello

[Gast]

Im Konstruktor wird myClass initialisiert. Mit dem Standardkonstruktor der Klasse 'KlassenName'.

Wenn du danach nochmal was an myClass zuweisen willst, muss der operator = definiert werden. Dir ist ja schon klar, dass 'myClass' ein Objekt der Klasse ist und keine Referenz auf ein Objekt der Klasse?

So, wenn ich dich jetzt falsch verstanden habe, liegt es einzig und allein daran, dass du alle möglichen Begriffe durcheinander wirfst, deine Variablen falsch benennst (eine Variable mit dem Namen 'myClass' ) und dich völlig unverständlich ausdrückst.

[interpreter]

Gehirnmann! schrieb:

hi,
wenn ich das zweite mache, dann brauche ich was extra in meiner klasse:

...xxx.cpp(49): error C2582: 'operator =' function is unavailable in 'DialogRegionSetts'

Da ich aber die klasse net geschrieben hab, und auch net will (sehr gross), geht das net. Muss doch auch ohne "extras" gehen.

Tja. Entweder du schreibst einen oder du bietest entsprechende setter an, um die bestehende Instanz zu verändern.

zu drittens:
ist doch klar: wenn ich das mache habe ich zwar local eine referenz

Nein, hast du nicht. Ich seh hier kein &.

aber wenn ich aus der funktion springe, ist die klassenvariable so wie vorher. bringt doch nix.
ich will ja klassenweit zuweisen.. ich dachte das wird klar

Sorry, ich kann nicht hellsehen. Klassenvariable? Bist du sicher, dass du weißt was eine Klassenvariable ist? (das ist das Ding mit static)
Ansonsten kann ich dir immer noch nicht helfen, weil du dich absolut unklar ausdrückst.

[Gehirnmann!]

puh. das war harte kritik.
aber mit ausdrücken musst du ja wohl zumindest recht haben.
also langsam:
klasse - object - instanz.. schon klar.
frage: wie tun in C++ ?
ich deklariere im header
ich definiere im source file.
wenn ich definiere, will ich (scheint mir als einzigem logisch wies aussieht) auf meine deklaration zurückgreifen. sonst macht die deklaration nämlich keinen sinn!
geht denn sowas in C++ net?
ich will einfach ein klassweit deklarierte klasse instanzieren (im stack nicht im heap.. sonst ist das ja klar)

marcello

[Gehirnmann!]

"..klassenweit deklariertes object.." fuer alle dies wieder zu genau nehmen..

[Cocaine]

zu drittens:
Er meint wohl, daß er die Instanz nur lokal anlegt, aber an den Aufrufer zurückgeben will.

Da du (warum auch immer) kein new verwenden darfst, machste es entweder mit vom Aufrufer übergebene(n) Pointer/Referenz auf das bereits von ihm erstellte Objekt oder mit einer Smart-Pointer-Klasse (z.B. boost::shard_ptr, std::auto_ptr).

[interpreter]

Cocaine schrieb:

Da du (warum auch immer) kein new verwenden darfst, machste es entweder mit vom Aufrufer übergebene(n) Pointer/Referenz auf das bereits von ihm erstellte Objekt oder mit einer Smart-Pointer-Klasse (z.B. boost::shard_ptr, std::auto_ptr).

Wie soll er die Problematik mit einem Auto-Pointer umgehen, wenn er kein new benutzen darf?

[Gast]

ich will einfach ein klassweit deklarierte klasse instanzieren (im stack nicht im heap.. sonst ist das ja klar)

Bitte noch einmal anders. Daraus kann man nicht schlau werden. Ich hab zwar nur einen IQ von 35, aber das ist einfach unverständlich.

Eine Klasse instanzierst du so auf dem Stack:

class Gehirn        {...};

int main()
{
    Gehirn meinGehirn;    // Standardkonstruktor
    Gehirn einAnderesGehirn(80),    // Konstruktor Gehirn(int IQ)
}

[Gast]

Cocaine schrieb:

zu drittens:
Er meint wohl, daß er die Instanz nur lokal anlegt, aber an den Aufrufer zurückgeben will.

Da du (warum auch immer) kein new verwenden darfst, machste es entweder mit vom Aufrufer übergebene(n) Pointer/Referenz auf das bereits von ihm erstellte Objekt oder mit einer Smart-Pointer-Klasse (z.B. boost::shard_ptr, std::auto_ptr).

Vorsicht! Ein lokales Objekt darf *niemals* per Referenz oder Zeiger zurückgegeben werden. Und wenn der Zeiger einen noch so hohen IQ hat.
Rückgabe eines lokalen Objektes immer by value! Lasst das den Compiler optimieren.

[interpreter]

Ich weiß zwar nach wie vor nicht was du genau willst, aber vielleicht meinst du sowas mit "klassenweit deklariertes(?) Objekt":

class Mann;

class Mehirn {
   public:
      static Mann mann;  // gilt Klassenweit, hat allerdings nichts mit Heap oder Stack zu tun
};

[interpreter]

Optimizer schrieb:

Cocaine schrieb:

zu drittens:
Er meint wohl, daß er die Instanz nur lokal anlegt, aber an den Aufrufer zurückgeben will.

Da du (warum auch immer) kein new verwenden darfst, machste es entweder mit vom Aufrufer übergebene(n) Pointer/Referenz auf das bereits von ihm erstellte Objekt oder mit einer Smart-Pointer-Klasse (z.B. boost::shard_ptr, std::auto_ptr).

Vorsicht! Ein lokales Objekt darf *niemals* per Referenz oder Zeiger zurückgegeben werden. Und wenn der Zeiger einen noch so hohen IQ hat.
Rückgabe eines lokalen Objektes immer by value! Lasst das den Compiler optimieren.

Genau das meinte ich. Wüsste nicht was da ein Auto-Pointer helfen sollte...

[davie]

Gehirnmann! schrieb:

hi,
ich hab echt ein übles Problem:
wenn ich eine klasse anlege, kann ich ja bekanntlich folgendes tun:

KlassenName myClass(X,Y,Z);

damit erzeuge ich eine klasse mit X,Y,Z als parameter an den konstruktor.

nein, damit erzeugst du eine instanz der klasse "KlassenName" namens "myClass" über einen konstruktor, der X, Y und Z als argument bekommt.

im header (einer klasse):

im header - ok
im header einer klasse - meinst du in dem header, in dem eine klasse definiert wird? ich geh einmal davon aus.

KlassenName myClass;

d.h. ich stell mir jetzt einfach eine headerdatei vor, in der ca. folgendes steht

class KlassenName {
 //...
};

KlassenName myClass;

im sourcecode der selben klasse, irgendwo in einer funktion(.cpp)

im sourcecode der Klasse KlassenName, irgendwo in einer funktion - ok, entweder ich nehme an, du meinst jetzt in irgendeiner memberfunktion der klasse - was ich allerdings bezweifle, da du sagst, es ist nicht deine klasse, oder irgendwo in einer funktion. dann passt aber der erste teil des satzes nicht dazu.
also: irgendwo in einer funktion

myClass(X,Y,Z); // geht nicht (1)
myClass = KLassenName(X,Y,Z); // geht nicht (2)
KlassenName myClass(X,Y,Z);  // ist blödsinn, weil dann member der klasse                      // immer noch auf NULL zeigt. (3)

(1) geht nicht, außer du überlädst operator().
(2) geht nicht ohne passenden zuweisungsoperator
(3) erzeugt ein neues objekt namens myClass, das aber nur lokal in der funktion existiert und das globale myClass verdeckt.
Aha, langsam komme ich drauf, was du willst.

Wenn du operator= nicht überladen möchtest und du wenig bis keine angst hast, sachen mit der klasse zu tun, die ins auge gehen könnten, probier das:

//vorher fasse ich mal deinen code zusammen
//header.h
class KlassenName {
public:
  KlassenName (int, int, int); //den hast du ja offensichtlich
  KlassenName (); //den auch- vielleicht auch nur implizit
  KlassenName (const KlassenName &); //dito
private:
  KlassenName &operator = (const KlassenName &); //darauf hast du irgendwie keinen zugriff
};

KlassenName myClass; //das lieber nicht im header, da du sonst möglicherweise die odr verletzt

//foo.cpp
#include "header.h"

void funktion () {
  //myClass(X,Y,Z);
  //myClass = KLassenName(X,Y,Z);
  //KlassenName myClass(X,Y,Z); 
  //ok, probier mal folgendes:
   myClass.~KlassenName(); //zerstören wir das alte objekt
   new (&myClass) KlassenName(1,2,3); //und erzeugen wir ein neues.
}

hm, irgendwie unbefriedigend. du willst ja nicht zwei objekte erzeugen, sondern nur eines- andererseits willst du ein fertiges objekt haben und es danach nochmal erzeugen?
du willst es am stack haben und nicht am heap (dann könntest du nämlich per mit zeiger arbeiten)
sieht so aus, als müsstest du irgendwo einen mittelweg finden.
da ich aber jetzt die hälfte nur geraten habe, und nicht weiß, wie du es verwendest und wozu du dein objekt brauchst, kann ich dir nicht viel mehr sagen.

Gehirnmann! schrieb:

klasse - object - instanz.. schon klar.

sicher? lies lieber trotzdem einmal das: Verhältnis Klasse zu Objekt

ich deklariere im header
ich definiere im source file.

hört sich gut an, so wie ich es aber oben verstanden habe
definierst du im header deine klasse
definierst du im header eine instanz deiner klasse (moment, hat nicht irgendwer jetzt gemeint, du hättest irgendwo ein static?)
du definierst in einem source-file irgendeine funktion.

wenn ich definiere, will ich (scheint mir als einzigem logisch wies aussieht) auf meine deklaration zurückgreifen. sonst macht die deklaration nämlich keinen sinn!

die passende deklaration zu einem globalen

KlasseName myClass;

ist aber

extern KlassenName myClass;

ich will einfach ein klassweit deklarierte klasse instanzieren (im stack nicht im heap.. sonst ist das ja klar)

was du mit klassweit deklarierte klasse (oder objekt, wie du später korrigierst) meinst ist mir zwar nicht klar, aber wenn du irgendetwas global machst, bist du weder am stack noch im freispeicher.

fazit: ratespiele machen mich nervös.

[Gast]

Und geschwätzig. :p

[Cocaine]

Optimizer schrieb:

Vorsicht! Ein lokales Objekt darf *niemals* per Referenz oder Zeiger zurückgegeben werden. Und wenn der Zeiger einen noch so hohen IQ hat.
Rückgabe eines lokalen Objektes immer by value! Lasst das den Compiler optimieren.

Das meinte ich doch gar nicht. Meinte das:

void func(klasse *bla) // oder halt Referenz
{
  // benutze bla
}

int main()
{
  klasse bla;
  func(&bla);
}

@interpreter: Klar, die Smart-Pointer waren auch nur so 'ne Idee, falls es eine Übungsaufgabe wäre, in der er den Lehrer verarschen könnte...

[Gast]

Das macht schon der Compiler für dich, wenn du ein Objekt zurückgibst.

[Gehirnmann!]

tach auch!

also hat ja für richtig aufregung gesorgt
also davie hat mich verstanden! *juhu*
ich schau mir das gleich mal an... mal sehn was ich daraus schrauben kann

thx
marcello

[Gehirnmann!]

also ohne den mistigen operator zu definieren komm ich wohl net aus.
na gut. dann werdsch mir wohl mal der sache annnehmen *nerv*

danke für die mühe, auch wenns nicht einfach ist
komisch das sich dann alle immer gleich einig sind