Hallo alle, bin C#-Anfänger. Ich habe einen Strukturtyp angelegt, von dem ich eine Variable anlegen/ableiten möchte: public struct tStruktur { public byte Preset; public byte[] Data; public tWasAnderes[] Test; } Eine Variable davon lege ich so an: tStruktur Variable = new tStruktur(); Variable.Data = new byte[16]; Wenn ich die zweite Zeile nicht durchführe, dann läßt mich C# nicht auf die einzelnen Data-Bytes zugreifen - seh ich auch ein. Wie kann ich mit einer Zeile eine vollständig definierte Strukturvariable erzeugen, auf deren Elemente ich vollständig zugreifen kann, ohne vorher die zig Element(arrays) explizit zu initialisieren? (Wenns hilft: Alle Größen aller Felder stehen zur Compilezeit schon fest! Und: die "16" direkt in der Strukturdefinition "public byte[16] Data;" erzeugt einen Fehler "] erwartet"). Wie geht? Welche wichtigen Infos habe ich vergessen? Gruß, Richard
Schreib doch einfach eine Klasse "CTObject" abgeleitet von CObject dann mußt du einmalig einen Konstruktor und Destruktor schreiben und bei jeden "erzeugen" = new von dieser Klasse werden alle entsprechenden Dinge ausgeführt. Bsp:
1 | class CTObject : public CObject |
2 | {
|
3 | public:
|
4 | // Konstruktor
|
5 | CTObject(void); |
6 | // Destruktor
|
7 | ~CTObject(void); |
8 | |
9 | // andere Funktionen
|
10 | UINT GetChecksumOfData(void) { return(data[0]+data[1]); }; |
11 | |
12 | public:
|
13 | // Deine Struktur-Variablen
|
14 | byte Preset; |
15 | byte[] Data; |
16 | tWasAnderes[] Test; |
17 | };
|
18 | |
19 | // Implementierung Konstruktor
|
20 | CTObject::CTObject(void) |
21 | {
|
22 | Data = new byte[16]; |
23 | Test = new tWasAnderes[4]; |
24 | Preset = 0x12 |
25 | }
|
26 | |
27 | // Implementierung Destruktor
|
28 | CTObject::~CTObject(void) |
29 | {
|
30 | if (Data) { |
31 | delete Data; |
32 | Data = NULL; |
33 | }
|
34 | if (Test) { |
35 | delete Test; |
36 | Test = NULL; |
37 | }
|
38 | }
|
Der Vorteil einer Klasse liegt auf der Hand, die "Initialisierungen" werden bei JEDEM erzeugen der Klasse gemacht. Also egal ob per new oder lokal auf dem Stack oder global oder innerhalb einer anderen Klasse. Nächster Vorteil ist auch das zugehörige Funktionen gleich mitgeliefert werden können (CTObject::GetChecksumOfData). Das ist ein wesentlicher Vorteil wenn mann "Objektorientiert Programmiert" - es gibt aber noch VIEL mehr das dazugehört. Es ist nämlich möglich "Beziehungen" zu bilden zwischen den Klassen (ein Rad gehört zu einem Auto/Fahrrad diese wiederum gehören zu Fahrzeugen ...). Es ist auch möglich "private" Variablen zu verwendet (die also NICHT von außerhalb dieser Klasse angesprochen werden dürfen). Der Source oben ist ungetestet - also gilt: wer Fehler findet darf sich melden. Gruss
Hallo Thomas,
eigentlich glaube ich (da Anfänger), daß ich das schon so mache wie
du beschreibst (d.h. das Anlegen der Variablen im Konstruktor einer
Klasse). Mein Beispiel oben war verkürzt dargestellt.
Aber auch in deinem Beispiel:
CTObject::CTObject(void)
{
Data = new byte[16];
Test = new tWasAnderes[4];
Preset = 0x12
}
musst du beim "instanziieren" die ganzen (es sind mehr als die hier
angegeben) Felder vorbelegen. Eigentlich habe ich eine Struktur, die
aus einzelnen anderen Strukturen besteht, die wiederum aus
verschiedenen anderen Strukturen bestehen usw. Ich verliere den
Überblick, von was ich alles mit "var = new Typ[xxx];" anlegen muß
und was nicht.
Deshalb die Frage, ob das nicht mit einem Einzeiler zu erschlagen wäre,
da ja die Feldgrößen usw. alle schon zur Compilezeit feststehen.
Initialisiert (damit meine ich mit konkreten Werten vorbelegt) müssen
die ganzen Werte nicht sein. (Das geschieht im weiteren Programmablauf
an separater Stelle).
Einzeiler deshalb, weil ich nur genau eine Variable "var" vom Typ
tStruktur erzeugen will, die aus vielen Unterelementen besteht.
> es gibt aber noch VIEL mehr das dazugehört.
ja, leider. Komme aus der embedded Programmierung und möchte mich jetzt
in die OOP einarbeiten.
Gruß, Richard
Vorschlag 1: > Eigentlich habe ich eine Struktur, die > aus einzelnen anderen Strukturen besteht, die wiederum aus > verschiedenen anderen Strukturen bestehen jede Struktur in Klasse verpacken, dann ist die überlegung was zu initialisieren ist einfachen Vorschlag 2: Wenn es nur darum geht eine (zur Compilerzeit) feste Größe zu verwenden kannst du die Membervariablen auch gleich so groß definieren
1 | class CTObject : CObject |
2 | {
|
3 | public:
|
4 | byte Data[16]; |
5 | };
|
Auch ich bin nicht der "Guru" in Sachen OOP, habe mit der MFC das erste mal richtig Kontakt gehabt (und genügend geflucht). Davor hatte ich nur 'C' programmiert. Gruss
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.