Objekte zur Verfügung stellen, global in Klasse

leon22

Nein ich meinte schon Call by Address

zB

void TestMethode(string* testString)
{
...
}

Noch einmal genauer:

Ich habe eine Klasse mit sagen wir 6 Methoden und dort brauche ich mehr oder weniger immer die selben Objekte und muss sie so immer mit übergeben ->

wie löse ich das komfortabler ?!

lg leon22

Simon2

leon22 schrieb:

...

void TestMethode(string* testString)
{
...
}

...

Sowas nennt man "call by reference" ...
"Reference" bezeichnet hier nicht automatisch einen bestimmten Sprachbaustein.

Gruß,

Simon2.

Fellhuhn

In dem Kontext entspricht Call by Address Call by Reference. Dient nur zur Unterscheidung zu Call by Value. Im Grunde sind Referenzen intern auch nichts anderes als restriktivere Adressen/Pointer.

Du willst dir also die Übergabe aller einzelnen Parameter sparen da sie ständig durchgereicht werden und es eh immer die gleichen sind?

Wenn es nur um die Ersparnis geht, kannst du dir ja auch ein Parameter-Struct basteln, in dem du die Pointer zu den Objekten ablegst und dieses immer durchreichst. Dann hast nur einen Parameter den du nur einmal füllen musst.

leon22

Das wäre natürlich auch eine komfortable Lösung

-> aber sollte ich statt des Structs nicht eine Klasse verwenden (Structures sind doch eher in C in Verwendung) !

lg

Simon2

leon22 schrieb:

Das wäre natürlich auch eine komfortable Lösung

-> aber sollte ich statt des Structs nicht eine Klasse verwenden (Structures sind doch eher in C in Verwendung) !

lg

struct = class + default-public

So ist z.B.

class A {   int i; }
struct B { int i; }

dasselbe wie

class A {   public: int i; }
struct B { private: int i; }

Gruß,

Simon2.

Fellhuhn

Im Grunde kein Unterschied, abgesehen davon das structs default public sind und classes private. Der Übersicht halber nehme ich für reine Datenbündel structs.

leon22

Danke !

Könntest du mir vielleicht noch ein kleines Beispiel liefern !?

mfg leon22

Fellhuhn

struct Wrap{
  T1 *p1;
  T2 *p2;
  T3 *p3;
};

void startKram(T1 *p1, T2 *p2, T3 *p3){
  Wrap w;
  w.p1 = p1;
  w.p2 = p2;
  w.p3 = p3;
  weitermachen(w);
}

void weitermachen(Wrap &wrap){
  machirgendfwas(wrap.p1);
  undNochWeiter(wrap);
}

leon22

Danke vielmals !

mfg leon22

Nexus

leon22 schrieb:

Ich habe eine Klasse mit sagen wir 6 Methoden und dort brauche ich mehr oder weniger immer die selben Objekte und muss sie so immer mit übergeben ->

wie löse ich das komfortabler ?!

Kannst du die übergebenen Objekte nicht als Member der Klasse speichern? Z.B. beim Konstruktoraufruf übergibst du sie einmal (z.B. als Referenz), und kannst sie dann später immer wieder brauchen...

leon22

So hab es nun mit der Übergabe an den Konstruktor probiert, aber irgendwie kennt er die Objekte dann nicht !

Konstruktor:

Test::Test(Class1* class1, Class2* class2, Class3* class3)
{
}

Objekt erstellen:

Test test(class1, class2, class3);

dann zB in

Test::DoAnything()
{
   class1->TestMethode(); // wird nicht erkannt

}

Hab ich noch etwas vergessen ?

Danke und mfg leon22

}

simon.gysi

Test::DoAnything() 
{ 
   class1->TestMethode(); // class1 ist doch ein Pointer!!

}

leon22

Ja, hab mich nur verschrieben !

Sonst müsste es passen oder ?

mfg leon22

unskilled

Test::Test(Class1* class1, Class2* class2, Class3* class3)
{
}

Ist aber nicht der gesamte CTor, oder? Oo
Ansonsten: guck dir mal nen paar Tuts über Klassen an...

bb

Nexus

unskilled schrieb:

Test::Test(Class1* class1, Class2* class2, Class3* class3)
{
}
Ist aber nicht der gesamte CTor, oder? Oo
Ansonsten: guck dir mal nen paar Tuts über Klassen an...

Das würde ich dir unbedingt auch raten (besser wäre, du schaust dir auch Funktionen noch einmal gut an). Da fehlt nämlich einiges.

Im Übrigen kannst du in diesem Falle auch Referenzen statt Zeiger benutzen.