mikrocontroller.net

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


Autor: Richard (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Thomas Stütz (tstuetz)
Datum:

Bewertung
0 lesenswert
nicht 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:
class CTObject : public CObject
{
  public:
    // Konstruktor
    CTObject(void);
    // Destruktor
    ~CTObject(void);

    // andere Funktionen
    UINT GetChecksumOfData(void) { return(data[0]+data[1]); };

  public:
    // Deine Struktur-Variablen
    byte          Preset;
    byte[]        Data;
    tWasAnderes[] Test;
};

// Implementierung Konstruktor
CTObject::CTObject(void)
{
  Data   = new byte[16];
  Test   = new tWasAnderes[4];
  Preset = 0x12
}

// Implementierung Destruktor
CTObject::~CTObject(void)
{
  if (Data) {
    delete Data;
    Data = NULL;
  }
  if (Test) {
    delete Test;
    Test = NULL;
  }
}

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

Autor: Richard (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Thomas Stütz (tstuetz)
Datum:

Bewertung
0 lesenswert
nicht 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
class CTObject : CObject 
{
  public:
    byte Data[16];
};

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 schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.