Auf Daten einer anderen Klasse zugreifen
Nachdem ich nochmals in meinem Buch nachgelesen und im Inernet gesucht habe (WIRKLCIH!! :-)) konnte ich mein Problem trotzdem nicht lösen. Ich möchte ganz einfach auf Daten einer Klasse von einer anderen aus zugreifen. Dazu habe ich z.B. 2 Headerdateien und 2 worin sich der Code befindet: header1.h: ... class Klasse1 { public QString hallo; ...} code1.cpp: hallo="hallo, Welt!"; ... header2.h: class Klasse2 { ... } code2..cpp: #include "header1.h" #include "header2.h" cout << hallo << endl; Soweit ich das verstanden habe, müsste es doch so in etwa funktionieren, oder? Nur bekomme ich ungefähr so eine Fehlermeldung: undeclared indentifier hallo Hä? Wenn es public ist, müsste ich doch auch aus anderen Klassen zugreifen können, oder? Die Aufrüfe von hallo erfolgen jeweils im Kontruktor von Klasse1 bzw. Klasse2. P.S. Das oben sind natürlich nur vereinfachte Beispiele. Danke Holger -- Ich bin nicht sicher, mit welchen Waffen der dritte Weltkrieg ausgetragen wird, aber im vierten Weltkrieg werden sie mit Stöcken und Steinen kämpfen. --Albert Einstein
Hallo Holger, hallo ist in deinem Beispiel eine Variable *eines Objektes* der Klasse1. (Ohne auf die Verteilung auf verschiedene Dateien zu achten) hier ein ungetesteter Vorschlag: #include <iostream> class Klasse1 { public: QString hallo; }; class Klasse2 { public: Klasse1 mK1; void set() { mK1.hallo = QString("hallo welt"); } void print() { std::cout << mK1.hallo << std::endl; } }; int main() { Klasse2 k2; k2.set(); k2.print(); } Hilft dir das weiter? Grüße Stefan On 26 Mar 2003 at 16:29, Holger Macht wrote:
Nachdem ich nochmals in meinem Buch nachgelesen und im Inernet gesucht habe (WIRKLCIH!! :-)) konnte ich mein Problem trotzdem nicht lösen.
Ich möchte ganz einfach auf Daten einer Klasse von einer anderen aus zugreifen. Dazu habe ich z.B. 2 Headerdateien und 2 worin sich der Code befindet:
header1.h: ... class Klasse1 { public QString hallo; ...}
code1.cpp: hallo="hallo, Welt!"; ...
header2.h: class Klasse2 { ... }
code2..cpp: #include "header1.h" #include "header2.h" cout << hallo << endl;
Soweit ich das verstanden habe, müsste es doch so in etwa funktionieren, oder? Nur bekomme ich ungefähr so eine Fehlermeldung: undeclared indentifier hallo Hä? Wenn es public ist, müsste ich doch auch aus anderen Klassen zugreifen können, oder? Die Aufrüfe von hallo erfolgen jeweils im Kontruktor von Klasse1 bzw. Klasse2.
P.S. Das oben sind natürlich nur vereinfachte Beispiele.
Danke Holger
-- Ich bin nicht sicher, mit welchen Waffen der dritte Weltkrieg ausgetragen wird, aber im vierten Weltkrieg werden sie mit Stöcken und Steinen kämpfen. --Albert Einstein
-- Um die Liste abzubestellen, schicken Sie eine Mail an: suse-programming-unsubscribe@suse.com Um eine Liste aller verfügbaren Kommandos zu bekommen, schicken Sie eine Mail an: suse-programming-help@suse.com
Am Mittwoch, 26. März 2003 16:38 schrieb Stefan Sassenberg:
Hallo Holger,
hallo ist in deinem Beispiel eine Variable *eines Objektes* der Klasse1.
(Ohne auf die Verteilung auf verschiedene Dateien zu achten) hier ein ungetesteter Vorschlag:
#include <iostream>
class Klasse1 { public: QString hallo; };
class Klasse2 { public: Klasse1 mK1; void set() { mK1.hallo = QString("hallo welt"); }
Jetzt habe ich verstanden, dass ich erst ein Object der Klasse Klasse1 erstellen muss, um dann auf Membervariabln zugreifen zu können. Da stellet sich aber nun ein neues Problem: Ich möchte den Wert der einen Klasse übergeben. Wenn ich aber ein neues Object der Kalsse erstelle, wird auch die Variable neu erzeugt (hallo) und damit ihr Inhalt gelöscht. Falls ich sie aber als static deklariere bekomme ich folgende Fehlermeldung: undefined reference to `Klasse1::hallo' Also in Klasse1 soll hallo ein Wert zugewiesen weden und in Klasse2 will ich dann darauf zugreifen. Danke Holger
On 26 Mar 2003 at 17:26, Holger Macht wrote:
Am Mittwoch, 26. März 2003 16:38 schrieb Stefan Sassenberg:
Hallo Holger,
hallo ist in deinem Beispiel eine Variable *eines Objektes* der Klasse1.
(Ohne auf die Verteilung auf verschiedene Dateien zu achten) hier ein ungetesteter Vorschlag:
#include <iostream>
class Klasse1 { public: QString hallo; };
class Klasse2 { public: Klasse1 mK1; void set() { mK1.hallo = QString("hallo welt"); }
Jetzt habe ich verstanden, dass ich erst ein Object der Klasse Klasse1 erstellen muss, um dann auf Membervariabln zugreifen zu können. Da stellet sich aber nun ein neues Problem: Ich möchte den Wert der einen Klasse übergeben. Wenn ich aber ein neues Object der Kalsse erstelle, wird auch die Variable neu erzeugt (hallo) und damit ihr Inhalt gelöscht. Falls ich sie aber als static deklariere bekomme ich folgende Fehlermeldung:
undefined reference to `Klasse1::hallo'
Also in Klasse1 soll hallo ein Wert zugewiesen weden und in Klasse2 will ich dann darauf zugreifen.
Das hab ich nicht ganz kapiert, aber vielleicht hast du noch ein konzeptionelles Problem damit. Daher die Frage: Wo ist denn dieses Objekt der Klasse1 definiert? Wem gehört es? In meinem Beispiel enthält jedes Objekt der Klasse2 ein eigenes Objekt der Klasse1. Soll jedes Objekt der Klasse1 auf das selbe hallo zugreifen, ist die Deklaration mit "static" schon richtig. Jedoch muss man dazu beachten, dass solche Variablen zusätzlich außerhalb der Klassendeklaration deklariert werden müssen, da alles was innerhalb der geschweiften Klammern der Klassendeklaration steht, zum Objekt dieser Klasse gehört und statische Variablen nicht einem Objekt (sondern allen) zugehörig ist. Füge also ein (z. B. vor int main()): QString Klasse1::hallo; und es sollte gehen. Grüße Stefan
Also nochmal von ANfang an: Mein Problem: Ich habe in QT zwei topLevelWindows also 2 verschiedene Klassen. Also keines ist ein child des Anderen. In der einen will ich dem QString Dateiname einen Wert zuweisen. In der anderen will ich dann auf diesen Dateinamen zugreifen. Mein Grundprinzip also (soweit ich es verstanden habe): Fenster/Klasse 1: 1. Deklarieren einer Variable Dateiname als QString und static 2. Dieser Variable einen Wert zuweisen Fenster/Klasse 2: 3. EIn Objekt der Klasse 1 erstellen 4. Auf die Variable Dateiname mit dem Wert aus Klasse 1 zugreifen: (Klasse1.Dateiname) Also so will ich es machen. Vielleicht ist jetzt mien Ziel etwas deutlicher geworden. Danke für die Nachsicht *g* Holger
Mein Problem: Ich habe in QT zwei topLevelWindows also 2 verschiedene Klassen. Also keines ist ein child des Anderen.
In der einen will ich dem QString Dateiname einen Wert zuweisen.
In der anderen will ich dann auf diesen Dateinamen zugreifen.
Mein Grundprinzip also (soweit ich es verstanden habe):
Fenster/Klasse 1: 1. Deklarieren einer Variable Dateiname als QString und static
Da Du wahrscheinlich ohnehin eine Instanz des Fensters erzeugen wirst, ist es eigentlich unsinnig, die Variable static zu deklarieren. Das macht nur Sinn, wenn man eine von Instanzen unabhaengige Variable braucht oder wenn mehrere Instanzen eine Variable gemeinsam benutzen wollen.
2. Dieser Variable einen Wert zuweisen
Fenster/Klasse 2: 3. EIn Objekt der Klasse 1 erstellen 4. Auf die Variable Dateiname mit dem Wert aus Klasse 1 zugreifen: (Klasse1.Dateiname)
Ich Hab nie etwas mit QT gemacht, aber hier eine allgemeine Loesung mit einer nicht-statischen Variablen und sinngemaessen Funktionsnamen: class Klasse1 { public: QString dateiname; Klasse1() { } void zeigeDialog() { // hier bekommt dateiname seinen Wert } }; class Klasse2 { Klasse1 dateiAuswahlDialog; public: Klasse2() { } void waehleDatei() { dateiAuswahlDialog.zeigeDialog(); QString datei = dateiAuswahlDialog.dateiname; } }; int main() { Klasse2 k2; } Das wuerden allerdings die meisten (mich inklusive) als unsaubere Datenkapselung bezeichnen. Sauber waere, Du wuerdest in Klasse1 die Variable private deklarieren und dafuer eine oeffentliche Funktion wie holeDateiName() zur Verfuegung stellen. Bye -- | Bodo Kaelberer | http://www.webkind.de/ | http://www.mehr-demokratie-wagen.de/ ---- | Haben oder Nichts sein
Hi all, Am Mittwoch, 26. März 2003 18:11 schrieb Holger Macht:
Mein Problem: Ich habe in QT zwei topLevelWindows also 2 verschiedene Klassen. Also keines ist ein child des Anderen.
In der einen will ich dem QString Dateiname einen Wert zuweisen. In der anderen will ich dann auf diesen Dateinamen zugreifen.
Mein Grundprinzip also (soweit ich es verstanden habe):
Fenster/Klasse 1: 1. Deklarieren einer Variable Dateiname als QString und static 2. Dieser Variable einen Wert zuweisen Fenster/Klasse 2: 3. EIn Objekt der Klasse 1 erstellen 4. Auf die Variable Dateiname mit dem Wert aus Klasse 1 zugreifen: (Klasse1.Dateiname)
// This is a sample schema file for GCC++ // Process this file by "jeeves -T Test.template Test.sc class Salut { string file; void set_file(string s); string get_file(); }; class Surname { string text; void set_text(string s); }; //---> main.cpp int main() { Salut hallo; Surname text; hallo = Salut; text = Surname; hallo.set_file("./file.dat"); text.set_text( hallo.get_file() ); return 0; }
Also so will ich es machen. Vielleicht ist jetzt mien Ziel etwas deutlicher geworden.
Da gibt's mehrere Wege, am besten lief ein Tutorial über OOP & Co. Ohne Bezug auf eine Sprache, dann klappt's besser mit C++. Ich bin selber fast Wahnsinnig geworden, aber OOP hab' ich so besser verstanden... ;)) Ciao Andre
Am Mit, 2003-03-26 um 17.26 schrieb Holger Macht:
Am Mittwoch, 26. März 2003 16:38 schrieb Stefan Sassenberg:
Hallo Holger,
hallo ist in deinem Beispiel eine Variable *eines Objektes* der Klasse1.
(Ohne auf die Verteilung auf verschiedene Dateien zu achten) hier ein ungetesteter Vorschlag:
#include <iostream>
class Klasse1 { public: QString hallo; };
class Klasse2 { public: Klasse1 mK1; void set() { mK1.hallo = QString("hallo welt"); }
Jetzt habe ich verstanden, dass ich erst ein Object der Klasse Klasse1 erstellen muss, um dann auf Membervariabln zugreifen zu können. Ja.
Da stellet sich aber nun ein neues Problem: Ich möchte den Wert der einen Klasse übergeben. Wenn ich aber ein neues Object der Kalsse erstelle, wird auch die Variable neu erzeugt (hallo)
Ja.
und damit ihr Inhalt gelöscht. Nein, es wird ein neues, anderes Feld "hallo" erzeugt, das "Teil eines andere Objektes" ist.
Falls ich sie aber als static deklariere bekomme ich folgende Fehlermeldung:
undefined reference to `Klasse1::hallo'
http://www.fmi.uni-konstanz.de/~kuehl/c++-faq/ctors.html#faq-10.9 http://www.fmi.uni-konstanz.de/~kuehl/c++-faq/ctors.html#faq-10.10 Ralf
hi
Ich möchte ganz einfach auf Daten einer Klasse von einer anderen aus zugreifen. Dazu habe ich z.B. 2 Headerdateien und 2 worin sich der Code befindet:
header1.h: ... class Klasse1 { public QString hallo; ...}
code1.cpp: hallo="hallo, Welt!"; ...
header2.h: class Klasse2 { ... }
code2..cpp: #include "header1.h" #include "header2.h" cout << hallo << endl;
Soweit ich das verstanden habe, müsste es doch so in etwa funktionieren, oder? Nur bekomme ich ungefähr so eine Fehlermeldung: undeclared indentifier hallo Hä? Wenn es public ist, müsste ich doch auch aus anderen Klassen zugreifen können, oder? Die Aufrüfe von hallo erfolgen jeweils im Kontruktor von Klasse1 bzw. Klasse2.
P.S. Das oben sind natürlich nur vereinfachte Beispiele.
Aha. Also ich weiss nicht, ob nicht etwas mehr Code dem Verstaendnis foerderlich gewesen waere (-; Ist die Zeile cout << hallo << endl; innerhalb einer Funktion von Klasse2? Also von Deinem Code her nicht. Weil sonst koennte unmoeglich direkt davor header2.h geladen werden. Auf hallo aus Klasse1 kannst Du von einer anderen Klasse nur zugreifen, wenn auch ein Objekt von Klasse1 hast. z.B. class Klasse2 { Klasse1 MeinHalloSprecher; public: void funktion() { cout << MeinHalloSprecher.hallo << endl; } }; (ungetestet)
code2..cpp: #include "header1.h" #include "header2.h" cout << hallo << endl;
Vielleicht magst Du, wenn Dir Stefans Antwort nicht das gewuenschte liefern sollte, noch mal etwas mehr Code posten, so dass die Zusammenhaenge erkennbar sind. Bye P.S. Deklarationen von Klassen werden mit einem ; abgeschlossen. -- | Bodo Kaelberer | http://www.webkind.de/ | http://www.mehr-demokratie-wagen.de/ ---- | Haben oder Nichts sein
Hallo, On Wed, 26 Mar 2003, Holger Macht wrote:
Ich möchte ganz einfach auf Daten einer Klasse von einer anderen aus zugreifen.
Auf die Gefahr hin, dass ich mich blamiere: Was spricht eigentlich gegen eine globale Variable (oder eine Instanz einer Klasse)? ==== bar.hh ==== class bar { public: bar(); }; ==== ==== foo.hh ==== class foo { public: foo(); }; ==== ==== main.hh ==== #include <string> #include <iostream> extern string dateiname; ==== ==== bar.cc ==== #include "main.hh" #include "bar.hh" bar::bar() { std::cout << "bar(): " << dateiname << std::endl; }; ==== ==== foo.cc ==== #include "main.hh" #include "foo.hh" foo::foo() { std::cout << "foo(): " << dateiname << std::endl; }; ==== ==== main.cc ==== #include "main.hh" #include "foo.hh" #include "bar.hh" string dateiname; int main(int argc, char * argv[]) { dateiname = "blubb"; std::cout << "main(): " << dateiname << std::endl; foo f; bar b; return 0; } ==== Die Variable kann man ggfs. ja in einen passenden Namespace verpacken. Wenn's mehrere sind, ist wohl eine struct oder eine Klasse verwenden. Man denke z.B. an Kommandozeilenoptionen die "globale flags" setzen (z.B. "verbose", "debug" o.ae.)... -dnh -- "Given the choice of condoms, your gentialia turning green and dropping off, or celerycy^W clebrat^W not getting any, condoms are often a clear winner." -- Chris Hacking in the scary devil monastery
Hi David, Am Mittwoch, 26. März 2003 20:20 schrieb David Haller:
On Wed, 26 Mar 2003, Holger Macht wrote:
Ich möchte ganz einfach auf Daten einer Klasse von einer anderen aus zugreifen. Was spricht eigentlich gegen eine globale Variable (oder eine Instanz einer Klasse)?
AFAIK, das im OOP die Daten Kapseln will :) Variablen sollten, demnach über Methode zugänglich sein. Ich denke, das es auch Gründe für globale Variablen gibt... Ciao Andre
Hallo, On Wed, 26 Mar 2003, Andre Heine wrote:
Am Mittwoch, 26. März 2003 20:20 schrieb David Haller:
On Wed, 26 Mar 2003, Holger Macht wrote:
Ich möchte ganz einfach auf Daten einer Klasse von einer anderen aus zugreifen. Was spricht eigentlich gegen eine globale Variable (oder eine Instanz einer Klasse)?
AFAIK, das im OOP die Daten Kapseln will :)
Variablen sollten, demnach über Methode zugänglich sein.
Aehm, naja, das halte ich fuer oft ueberfluessig. Accessoren halte ich fuer nur sinnvoll, wenn es gute Gruende gibt, die Variablen "private", "protected" oder "read only" zu halten (z.B. weil etwas "nebenbei" verwaltet werden muss, oder konkurrierende Zugriffe)... Dieses "blinde" get_foo() { return this.foo; } set_foo(X &y) { this.foo = y; } das halte ich schlicht fuer nervig und ueberfluessig...
Ich denke, das es auch Gründe für globale Variablen gibt...
Z.B. globale "Flags"/"Optionen" -- oder eben auch einen Dateinamen. Holger hat bisher noch zu wenig verraten, um eine Empfehlung geben zu koennen, welche Variante nun sinnvoller ist. Je nach Anwendung ist eben eine globale Variable (oder Klassen-Instanz) oder eben eine lokale geeigneter... Und ich wollte dies einfach nur erwaehnen, globale Variablen sind nicht immer "boese" ;) -dnh -- "The way NT mounts filesystems is something I'd expect to find in a barnyard or on a stock-breeding farm." -- Mike Andrews
participants (6)
-
Andre Heine -
Bodo Kaelberer -
David Haller -
Holger Macht -
Ralf Corsepius -
Stefan Sassenberg