imported>Invisigoth67: typo

2025-10-01T11:34:22Z

typo

Neue Seite

Ein '''Verbund''' ({{enS|''object composition''}}) ist ein [[Datentyp]], der aus einem oder mehreren Datentypen zusammengesetzt wurde. Die Komponenten eines Verbunds können wiederum Verbünde sein, wodurch auch komplexe [[Datenstruktur]]en definiert werden können.

Die Komponenten/Elemente eines Verbunds werden normalerweise nacheinander im Speicher angeordnet (beispielsweise als <code>struct</code> in der [[C (Programmiersprache)|Programmiersprache C]] bzw. als <code>record</code> in [[Pascal (Programmiersprache)|Pascal]]). Eine Ausnahme stellen [[#Unions|Unions]] dar. Auch in anderen [[Programmiersprache]]n (siehe unten) wird dieser Datentyp zum Teil unterschiedlich bezeichnet.

== Verwendung in verschiedenen Programmiersprachen ==
=== Strukturen in den Programmiersprachen C++ und C ===
In den Programmiersprachen [[C (Programmiersprache)|C]] und [[C++]] werden Verbünde (engl. auch ''composite types'') als '''Struktur''' bezeichnet und mit dem Schlüsselwort <code>struct</code> (kurz für engl. {{lang|en|''structure''}} ‚Struktur‘) deklariert. Die einzelnen Komponenten einer Struktur, die sog. {{lang|en|''members''}} ‚Mitglieder‘ dürfen dabei beliebige einfache Datentypen, Felder konstanter Größe oder ein [[Zeiger (Informatik)|Zeiger]] auf dieselbe Struktur sein.

Im Gegensatz zur [[#Unions|{{lang|en|''union''}}]] überlappen sich die Speicherbereiche der einzelnen Strukturmitglieder nicht.

==== Beispiel in C ====
<syntaxhighlight lang="c">
#include <stdio.h>

struct Person
{
int Personalnummer;
int Alter;
char Name[20];
};

struct Person *Person_anhand_Personalnummer(int);

int main(void)
{
struct Person *person = Person_anhand_Personalnummer(12345);

printf("Personalnummer: %i, Alter: %i\n",
person->Personalnummer,
person->Alter);
}
</syntaxhighlight>

Hat man einen [[Zeiger (C)|Zeiger]] auf die Struktur, dann wird, wie gezeigt, auf einzelne Members am einfachsten mithilfe des Pfeils <code>-></code> zugegriffen, bspw. {{nowrap|<code>person->Alter</code>}}. Der Pfeil (engl. ''arrow'') ist eine Kurzschreibweise für {{nowrap|<code>(*person).Alter</code>}} mit dem Stern <code>*</code> als Dereferenzierungsoperator (engl. ''dereference operator'') und dem Punkt <code>.</code> als Selektor (engl. ''object selector'').

==== Größe im Speicher ====
Eine Struktur kann größer sein als die Summe der einzelnen Datentypgrößen, da der [[Compiler]] die einzelnen Attribute im Speicher an bestimmten Adressen [[Speicherausrichtung|ausrichten]] kann. Die Anordnung der Struktur im Speicher ist nach der Übersetzung festgelegt und kann nicht mehr verändert werden.

==== Unterscheidung zwischen C++- und C-Struktur ====
In C können Strukturen lediglich [[Variable (Programmierung)|Variablen]], [[Zeiger (Informatik)|Zeiger]], [[Feld (Datentyp)|Arrays]] und andere Strukturen enthalten, während Strukturen in C++ die zusätzliche Fähigkeit besitzen, [[Unterprogramm]]e – sogenannte [[Methode (Programmierung)|Methoden]] – zu beinhalten, zu denen auch [[Konstruktoren und Destruktoren#Konstruktoren|Konstruktoren]] und [[Konstruktoren und Destruktoren#Destruktoren|Destruktoren]] gehören.<ref>{{Internetquelle |autor=Peter Becker, Andreas Bruchmann, Dirk F. Raetzel |url=http://ip-klaeden.dyndns.org/webseiten/cppkurs/oop2/struct.html |titel=Unterschiede zum Datentyp ''struct'' |werk=Kapitel 12: Objektorientiertes Programmieren in C++. In: C++ - Eine Einführung |hrsg=Manfred Sommer, Philipps-Universität Marburg |datum=2001-06-05 |offline=ja |archiv-url=https://web.archive.org/web/20140110170426/http://ip-klaeden.dyndns.org/webseiten/cppkurs/oop2/struct.html |archiv-datum=2014-01-10 |archiv-bot= |zugriff=2014-01-10 |kommentar=}}</ref> Dies lässt sich in C nur teilweise über Funktionszeiger realisieren, die auch Teil von Strukturen sein können.

==== Unterscheidung zwischen C++-Struktur und C++-Klasse ====
In C++ dienen die Schlüsselwörter <code>public</code> und <code>private</code> dazu, die Zugriffsrechte auf Attribute und Methoden in Strukturen und Klassen zu regeln. Der einzige Unterschied hier ist, dass ohne explizite Angabe die Attribute von Strukturen standardmäßig <code>public</code> (Zugriff von außen erlaubt), die einer Klasse <code>private</code> (Zugriff nur von innerhalb der Klasse oder durch [[Friend-Funktion]]en) sind.<ref>[http://www.cplusplus.com/doc/tutorial/classes/ ''Classes (I)''] auf cplusplus.com</ref>

=== Implementierung in Pascal ===
Ein Verbund (in Pascal mit <code>record</code> bezeichnet) vom Datentyp <code>Person</code> für die beiden Instanzen <code>Mustermann1</code> und <code>Mustermann2</code> könnte in [[Component Pascal]] zum Beispiel folgendermaßen definiert und verwendet werden, und nur Instanzen desselben Datentyps sind in dieser Programmiersprache [[Zuweisungskompatibilität|zuweisungskompatibel]]:
<syntaxhighlight lang="pascal">
MODULE Personen;

IMPORT Dates;

TYPE
Person = RECORD
Vorname, Name, Wohnort: ARRAY 256 OF CHAR;
Geburtstag: Dates.Date;
END;

VAR Mustermann1, Mustermann2: Person;

BEGIN

Mustermann1.Vorname := "Hans";
Mustermann1.Name := "Mustermann";
Mustermann1.Wohnort := "Musterstadt";
Mustermann1.Geburtstag.day := 1;
Mustermann1.Geburtstag.month := 1;
Mustermann1.Geburtstag.year := 1900;

Mustermann2 := Mustermann1; (* Zwei Variablen vom selben Datentyp sind zuweisungskompatibel *)

END Personen.
</syntaxhighlight>
Der importierte im [[Modul (Software)|Modul]] <code>Dates</code> definierte Datentyp <code>Dates.Date</code> ist wiederum ein Verbund mit den ganzzahligen Elementen <code>day</code> (Tag), <code>month</code> (Monat) und <code>year</code> (Jahr).

=== Implementierung in Swift ===
In [[Swift (Programmiersprache)|Swift]] werden Verbünde wie auch in C als <code>struct</code> definiert. Dabei wird jedoch festgelegt, dass Instanzen des Verbunds stets auf dem Stack gespeichert werden. Wird eine Instanz A eines <code>struct</code>s an eine andere Instanz B geschrieben, so erfolgt dies durch Kopieren des gesamten Speicherinhalts der Instanz A in den für die Instanz B reservierten Speicherbereich. Das Gleiche passiert beim Aufruf einer Funktion, die für einen Parameter ein struct als Typ vorsieht (siehe: [[Wertparameter]]).

Demgegenüber werden [[Klasse (Objektorientierung)|Klassen]] in Swift (definiert über das Keyword <code>class</code>) immer auf dem [[Heap (Datenstruktur)|Heap]] abgelegt und innerhalb der Variable stets als [[Referenz (Programmierung)|Referenz]] auf diesen Speicherbereich auf dem Heap geführt. Wird eine Variable A als Instanz einer Klasse einer Variablen B als Instanz derselben Klasse zugewiesen, so wird lediglich die Referenz kopiert.

=== Datengruppen in Cobol ===
In [[Cobol]] wird der Datentyp Verbund ''‚Datengruppe‘'' (auch ''Gruppen-Variable'' oder <code>group item</code>) genannt. Eine Datengruppe wird mit ihrem Bezeichner deklariert und ist der Überbegriff bzw. die Zusammenfassung für die ihr [[Hierarchie|hierarchisch]] untergeordneten Datentypen – die selbst wieder Datengruppen sein können. Sie hat selbst keine Formatspezifikation (PIC-Klausel). Über die <code>OCCURS</code>-Klausel kann auch eine Datengruppe als Tabelle (= [[Feld (Datentyp)|Array]]) deklariert werden, ggf. auch mehrstufig.

In den die Datengruppe ansprechenden Befehlen wird die Gesamtheit der ihr untergeordneten Felder als ein (1) [[Datenfeld]] im PIC-X-Characterformat und in der Gesamtlänge aller Einzelfelder behandelt. Bei einem <code>MOVE</code>-Befehl etwa findet also keine individuelle formatspezifische Verarbeitung der Einzelfelder statt, auch keine Formatkonvertierung.

Über die <code>REDEFINES</code>-Klausel kann eine Datengruppe eine andere Datengruppe 'redefinieren', wodurch beide Datengruppen denselben Speicherplatz benutzen. Angewendet wird dies beispielsweise für die Verarbeitung unterschiedlicher Eingabedaten, alternativ in der einen oder in der anderen Datenstruktur. Dies entspricht dem Konstrukt UNION in anderen Programmiersprachen.

== Unions ==
Bei sog. {{lang|en|''Unions''}} beginnen alle Komponenten an der gleichen [[Speicheradresse]], d. h., ihre Speicherbereiche überlappen sich ganz oder zumindest teilweise. Eine Union belegt dabei mindestens so viel Speicher, wie ihre größte Komponente.

Unions sind in verschiedenen Programmiersprachen entweder als tagged-Unions oder untagged-Unions implementiert.

Eine tagged-Union ordnet jeder Komponente einen Tag zu. Beim Schreiben einer Komponente wird der Tag dieser Komponente in der Union-Variable gespeichert. Bei Lesezugriffen auf die Komponente einer Union wird der Tag der zu lesenden Komponente mit dem Tag der letzten geschriebenen Komponente verglichen. Unterscheiden sich die Tags, ist ein Typfehler festgestellt. Somit sind tagged-Unions [[Typsicherheit|typsicher]].

Untagged-Unions verwenden keine Tags und sind deswegen typunsicher. D. h., es liegt in der Verantwortung des Programmierers, ob der letzte Schreibzugriff einer Union die gleiche Komponente verändert hat, die auch der darauf folgende Lesezugriff ausliest. Neben unbeabsichtigten Typfehlern bei der Verwendung von untagged-Unions existieren aber auch Anwendungsfälle für die [[Seiteneffekt]]e von untagged-Unions. Beispielsweise eine Union aus einer [[IEEE 754|IEEE-Gleitkommazahl]] und einer <code>struct</code>, deren Komponenten den Zugriff auf Vorzeichen, Mantisse und Exponent erlauben.

=== Beispiel in C ===
<syntaxhighlight lang="c">
#include <stdio.h>
#include <math.h>
#include <inttypes.h>

union Float64Components
{
double Float64;
struct
{
uint64_t Mantissa52 : 52;
uint64_t Exponent11 : 11;
uint64_t Sign1 : 1;
};
};

void main ()
{
union Float64Components pi;
pi.Float64 = 3.1415926535897932384626433832795;
printf ("%20.16f %13I64X %03I64X %01I64X (%20.16f)\n",
pi.Float64,
pi.Mantissa52, pi.Exponent11, pi.Sign1,
(pi.Sign1 ? -1 : +1) * (1.0 + pi.Mantissa52/4503599627370496.0) * pow (2, pi.Exponent11-1023));
}
</syntaxhighlight>

Output
3.1415926535897931 921FB54442D18 400 0 ( 3.1415926535897931)

=== Beispiel in Haskell ===
Beispiel der Deklaration einer Union in [[Haskell (Programmiersprache)|Haskell]]:
<syntaxhighlight lang="ocaml">
data Tree a = Br (Tree a) (Tree a) |
Leaf a |
Nil
</syntaxhighlight>
Tree ist ein algebraischer Datentyp. Br, Leaf und Nil sind die Konstruktoren.

=== Beispiel in Pascal ===
Unions in Pascal heißen ''variante Teile''.<ref>{{Internetquelle|url=https://docwiki.embarcadero.com/RADStudio/Athens/de/Strukturierte_Typen_(Delphi)#Variante_Teile_in_Record-Typen|titel=Strukturierte Typen (Delphi)|abruf=2024-06-02|werk=Delphi-Athens-Dokumentation}}</ref> Das folgende Beispiel macht einen Chunknamen, wie er z. B. in [[Portable Network Graphics|PNG]] vorkommt, wahlweise als vorzeichenlose 32-Bit-Ganzzahl (Cardinal) oder als [[Zeichenkette]] ansprechbar:
<syntaxhighlight lang="pascal">
type
TChunkname = record
case Boolean of
False: (Int: Cardinal);
True: (Str: array[0..3] of AnsiChar);
end;
</syntaxhighlight>
Anmerkungen:
* ''Boolean'' legt den Datentyp fest, aus dessen Wertebereich die case-Labels kommen müssen (hier ''False'' und ''True''). Es kann jeder [[Datentyp#Ordinale Datentypen|ordinale Datentyp]] dafür verwendet werden. Der genaue Typ spielt in untagged-Unions wie oben keine Rolle, solange der Wertebereich groß genug für alle möglichen Fälle ist (hier beides jeweils 2). Der Datentyp Integer mit den case-Labels ''42'' und ''4711'' hätte beispielsweise dasselbe Ergebnis. Bei untagged-Unions wird kein Speicher für den case-Ausdruck verwendet, sodass eine Instanz des obigen Records 4 Bytes belegt.
* Records können auch einen gemeinsamen Teil haben und nur teilweise eine Union sein, indem die gemeinsamen Felder vor dem case-Konstrukt deklariert werden. Die Union (das case-Konstrukt) muss immer am Ende stehen, da das case-Konstrukt als Union – anders als sonst – kein eigenes Ende hat. Es können aber Records verschachtelt werden, um diese Einschränkung zu umgehen.
* In Pascal gibt es auch tagged-Unions. Sie entstehen, wenn dem case-Datentyp ein Bezeichner gegeben wird. Das Tag belegt nur in diesem Fall Speicher entsprechend seines Datentyps und kann über den Bezeichner angesprochen werden. Allerdings hat das Tag keinerlei Schutzfunktion, denn Schreib- und Lesezugriffe müssen nicht auf Felder dasselben Tags erfolgen. Das Tag verhält sich somit wie ein Feld im gemeinsamen Teil des Records.

Bei Variablen, nicht jedoch Feldern von Datentypen, kann man in einigen Dialekten wie Delphi hinter dem Datentyp das Schlüsselwort ''absolute'' gefolgt vom Bezeichner einer anderen Variablen angeben, um deren Speicher mitzuverwenden.<ref>{{Internetquelle|url=https://docwiki.embarcadero.com/RADStudio/Athens/de/Variables_(Delphi)#Absolute_Adressen|titel=Variables (Delphi)|abruf=2024-06-02|werk=Delphi-Athens-Dokumentation}}</ref> So entsteht eine Art Ad-Hoc-Union. Andere Dialekte erlauben auch die Angabe einer Speicheradresse.

Alle Pascal-Datentypen belegen immer eine Größe in ganzen Bytes. Da auch die Felder in einer Union immer die volle Größe ihrer Datentypen einnehmen, ist das Zerlegen einer IEEE-754-Gleitkommazahl wie im C-Beispiel oben mit Unions alleine nicht möglich.

== Siehe auch ==
* [[Assoziatives Array]]

== Einzelnachweise ==
<references />

[[Kategorie:Datentyp]]
[[Kategorie:Programmiersprachelement]]

[[en:Object composition]]

Verbund (Datentyp) - Versionsgeschichte

imported>Invisigoth67: typo