Forum: PC-Programmierung Vom Typen zur Variable (C#)


von Richard (Gast)


Lesenswert?

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

von Thomas S. (tstuetz)


Lesenswert?

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

von Richard (Gast)


Lesenswert?

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

von Thomas S. (tstuetz)


Lesenswert?

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
Noch kein Account? Hier anmelden.