Beispiel

struct MyStruc{
      BYTE Id;
      DynamicArray <struct Data{
         BYTE PinId;
         BYTE PinNummer;         
         DynamicArray <BYTE> Prop;
         DynamicArray <BYTE> Para;
         BYTE FctId;                      
      }> Pin;
   };

   struct MyStruct2 {
      AnsiString Name;
      bool Checked;  // Ob Funktion in der Oberfläche ausgewählt ist
      bool Locked;   // Möglichkeit die Funktion von aussen her zu 
      DynamicArray <struct MyStruc> PossibleConnectors;
   };

für Grundlagen des OOP siehe hier.

bis bald
akari

struct MyStruc{
   BYTE Id;
   struct Data
   {
      BYTE PinId;
      BYTE PinNummer;
      DynamicArray <BYTE> Prop;
      DynamicArray <BYTE> Para;
      BYTE FctId;
      Data(const Data& src) : PinId(src.PinId), PinNummer(src.PinNummer), FctId(src.FctId)
      {
        Prop = src.Prop.Copy();
        Para = src.Para.Copy();
      }
   };
   DynamicArray <Data> Pin;
   MyStruc(const MyStruc& src) : Id(src.Id), Pin(src.Pin.Copy()) { }
};

Prop und Para könnte man eigentlich auch noch in die Initialisierungsliste packen. evtl. braucht man hier noch den Zuweisungsoperator.

MyStruct Test();

....

MyStruct Test2(Test);

Zur Laufzeit geht das nicht, oder? Muss ich dann lieber ne Klasse nehmen? ICh brauche es , da in einem Hauptteil Daten in der Struktur stehen und i einem zweiten Teil Änderungen vorgenommern werden an der zweiten Struktur, die ggf. verworfen werden. Wenn nicht, dann müssen sie wieder in die erste Struktur rein.

Der effiziente Weg ist, das du das was du nun in deinem Kopierkonstruktor stehen hast, in eine extra Funktion namens z.b. Assign() auszulagerst, die du dann vom Konstruktor aus aufrufst. Wenn du jetzt noch den Zuweisungsoperator = für dein struct überschreibst und diesen ebenfalls Assign aufrufen läßt, bist du für alle Übernahme-Fälle gerüstet.

struct und class sind fast äquivalent. Nur der Standard-Zugriffsbeschränkungen ist unterschiedlich (class = private, struct = public). Deshalb bringt ein Umbau nichts weiter.

bis bald
akari

Man könnte der struct auch eine swap-Funktion zum Austausch der Member geben. Dann kann man wieder all diese Funktionen über den Kopierkonstruktor erschlagen.