Vom Typen zur Variable (C#)

Richard Gast #250080
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
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Thomas S. #250081
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Richard Gast #250082
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thomas S. #250083
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren