Zuweisungskompatibilität

Zuweisungskompatibilität

Zuweisungskompatibilität liegt bei in Programmiersprachen formulierten Anweisungen vor, wenn Ausdrücke und Variablen aufgrund kompatibler Datentypen einander zugewiesen werden können.

Compiler oder Interpreter können bei typsicheren Programmiersprachen bereits im Quelltext prüfen, ob eine hinreichende Zuweisungskompatibilität vorliegt.[1] Um eine Typverletzung zu beheben, muss durch den Compiler beziehungsweise Interpreter eine implizite oder durch den Programmierer eine explizite Typumwandlung durchgeführt werden. In beiden Fällen kann es leicht zu Programmfehlern kommen und daher ist in vielen modernen Programmiersprachen die implizite Typumwandlung nur in den Ausnahmen zulässig, wo sie die Quelltexte vereinfacht, aber keine Gefahr darstellt.

Inhaltsverzeichnis

Strenge Zuweisungskompatibilität

Zuweisungen sind uneingeschränkt zulässig, wenn eine strenge Zuweisungskompatibilität gegeben ist. Dazu müssen die Datentypen des zuzuweisenden Ausdrucks und der Variable exakt übereinstimmen.

Bei Verbunden müssen die Anzahl, die Reihenfolge und die Datentypen aller Komponenten des Verbunds übereinstimmen, was dadurch gewährleistet werden kann, dass alle beteiligten Variablen mit demselben Datentyp deklariert worden sind.[2] Beispiel:

TYPE Mann = Verbund von INTEGER alter; und REAL groesse;

VARIABLE otto, emil: Mann;

otto.alter   := 50;
otto.groesse := 1.80;

emil := otto; (Alle Attribute vonottowerdenemilzugewiesen)

Bei Feldern ist die strenge Zuweisungskompatibilität nur gegeben, wenn der Basisdatentyp und die Länge identisch sind. Beispiel:

TYPE Vorname = Feld der Größe 4 von CHARACTER; (Zeichenkette der Länge 4)

VARIABLE personename: Vorname;

personename := "Hugo";      (Die KonstanteHugoist zuweisungskompatibel zur Variablenpersonenname“)
personename := "Alexander"; (Die KonstanteAlexanderist nicht zuweisungskompatibel zur Variablenpersonenname“)

Ein Sonderfall sind offene Felder mit nicht deklarierter Länge: Bei formalen Parametern beziehungsweise dynamisch erst zur Laufzeit vollständig definierten Feldern reicht zur Erlangung der Zuweisungskompatibilität die Übereinstimmung des jeweiligen Basisdatentyps der Felder.[3] Beispiel:

TYPE Vorname = Feld von CHARACTER; (Zeichenkette mit offener Länge)

VARIABLE personename: Vorname;

personename := "Hugo";      (Die Variablepersonennamewird dynamisch mit der Länge 4 erzeugt)
personename := "Alexander"; (Die Variablepersonennamewird erneut dynamisch erzeugt, diesmal mit der Länge 9)

Bei Prozedurvariablen müssen die Anzahl, die Art, die Reihenfolge und die Datentypen aller Parameter und Rückgabewerte übereinstimmen, also abgesehen vom Prozedurnamen die Signaturen der beiden Prozeduren übereinstimmen.

Zwei Instanzen sind in diesem Sinne zuweisungskompatibel, wenn sie exakt derselben Klasse angehören. Beispiel:

TYPE Rechteck = Klasse mit INTEGER breite, hoehe und mit Methode flaechenberechnung();

VARIABLE fenster1, fenster2: Rechteck;

fenster1.breite := 200;
fenster1.hoehe  := 100;
fenster1.flaechenberechnung(); (Flächenberechnung fürfenster1ausführen; Ergebnis = 20000)

fenster2 := fenster1; (Zuweisung ist möglich, da beide Instanzen derselben Klasse angehören)
fenster2.flaechenberechnung(); (Flächenberechnung auch fürfenster2ausführen; Ergebnis = 20000)

Logische Kompatibilität

Bei besonders strenger Betrachtungsweise sind sogar zwei identische Definitionen von Datentypen nicht zuweisungskompatibel, weil zwar die Daten eindeutig ineinander überführt werden können (technische Kompatibilität), aber zwei verschiedene Definitionen verwendet wurden (logische Kompatibilität).[4] Folgendes Beispiel wäre demzufolge technisch korrekt, aber nicht logisch:

TYPE Mann = Verbund von INTEGER alter; und REAL groesse;
TYPE Frau = Verbund von INTEGER alter; und REAL groesse;

VARIABLE otto: Mann;
VARIABLE anna: Frau;

otto.alter   := 50;
otto.groesse := 1.80;

anna := otto; (Zuweisung ist technisch möglich aber logisch nicht korrekt)

Um logische Programmfehler zu vermeiden, sind solche Zuweisungen mit impliziter Typumwandlung in einigen Programmiersprachen mit verhältnismäßig starker Typisierung, wie zum Beispiel Modula-2 oder Oberon, nicht zulässig.

Zuweisungskompatibilität ohne Informationsverlust

In gewissen Fällen kann die Information, die in einem Datentyp abgelegt ist, eindeutig und ohne Informationsverlust in einen anderen Datentyp überführt werden.

Typische Beispiele sind ganzzahlige Datentypen mit unterschiedlicher Speichergröße. So kann ein Integer mit 16 Bit Speichergröße eindeutig in einer vorzeichenbehafteten Integer-Variablen mit 32 Bit Speichergröße abgelegt werden, ohne dass die ursprünglich nur mit 16 Bit definierte Zahl verändert wird. Umgekehrt ist dies jedoch nicht immer möglich, insbesondere unter der Beachtung von Vorzeichen und zu großen Zahlen.

Weitere Beispiele ergeben sich bei Zeichenketten oder anderen Feldern, deren feste Länge verschieden ist. Das kürzere Feld kann im längeren gespeichert werden, aber nicht umgekehrt.

Zwei Instanzen sind ohne Informationsverlust zuweisungskompatibel, wenn sie die zuzuweisende Klasse derselben Klasse angehört wie die zugewiesene Klasse.

Beispiel mit Zuweisungskompatibilität

zahl1: BYTE; (mit 8 Bit für ganze Zahlen zwischen -128 bis +127)
zahl2: SHORTINT; (mit 16 Bit für ganze Zahlen zwischen -32768 bis +32767)

zahl1 := 55; (Zuweisung der ganzen Zahl 55 an die Variablezahl1“)
zahl2 := zahl1; (Zuweisung der ganzen Zahl 55 aus der Variablenzahl1an die Variablezahl2“)

Beispiel ohne Zuweisungskompatibilität

zahl1: BYTE; (mit 8 Bit für ganze Zahlen zwischen -128 bis +127)
zahl2: SHORTINT; (mit 16 Bit für ganze Zahlen zwischen -32768 bis +32767)

zahl2 := 555; (Zuweisung der ganzen Zahl 555 an die Variablezahl2“)
zahl1 := zahl2; (Ungültiger Versuch der Zuweisung der ganzen Zahl 555 aus der Variablenzahl2an die Variablezahl1“)

Bei einer solchen Zuweisung kann bereits der Compiler verhindern, dass ausführbarer Maschinencode erzeugt wird, da nicht sichergestellt werden kann, dass große Zahlen, die in der Variablezahl2gespeichert sind, immer auch ohne Informationsverlust in der Variablezahl1abgelegt werden können.

Bei fehlender Überprüfung durch den Compiler werden zwangsläufig und unbemerkt Ziffern abgeschnitten, so dass bei nachfolgenden Berechnungen unter Umständen grobe Berechnungsfehler auftreten können, die teilweise schwierig zu analysieren sind.

Zuweisungskompatibilität mit geringem Informationsverlust

Ein Sonderfall ist die Zuweisung von ganzen Zahlen an Variablen, die Gleitkommazahlen repräsentieren. Meist kann ohne die Gefahr von Programmfehlern toleriert werden, große ganze Zahlen implizit in Gleitkommazahlen umzuwandeln, da der Rechenfehler (wenn überhaupt vorhanden) hierbei sehr klein ist. Auch dies kann an einem Beispiel verdeutlicht werden:

zahl1: LONGINT; (mit 64 Bit für ganze Zahlen zwischen   263 bis  + 263  1))
zahl2: REAL; (mit 64 Bit für Gleitkommazahlen mit einer Mantisse mit maximal 14 Nachkommastellen nach IEEE 754)

zahl1 := 9223372036854775807; (Zuweisung der ganzen Zahl 263  1 an die Variablezahl1“)
zahl2 := zahl1; (Gültiger Versuch der Zuweisung der ganzen Zahl 263  1 aus der Variablenzahl1an die Variablezahl2“,
                 die allerdings anschließend den gerundeten Zahlenwert 9,22337203685478 \cdot {10}^{18} enthält)

Der Fehler durch das Abschneiden der letzten Nachkommastellen liegt hier also nur in einer Größenordnung von 10 14 und kann daher für praktisch alle Anwendungen vernachlässigt werden.

Zuweisungskompatibilität mit definiertem Informationsverlust

Zwei Instanzen sind mit definiertem Informationsverlust zuweisungskompatibel, wenn die zuzuweisende Klasse einer von der zugewiesenen Klasse abgeleiteten Klasse angehört. Alle Daten die in der zugewiesenen Klasse deklariert und somit erforderlich sind, können zugewiesen werden, jedoch werden die in der zuzuweisenden, abgeleiteten Klasse hinzugefügten Attribute und Methoden ignoriert. Beispiel:

TYPE Lebewesen = Verbund von INTEGER alter, gewicht;
TYPE Mensch = Lebewesen mit INTEGER intelligenzquotient; (Der Datentyp "Mensch" erbt alle Eigenschaften von Lebewesen)

VARIABLE otto: Mensch;
VARIABLE eukaryot: Lebewesen;

otto.alter               := 50;
otto.gewicht             := 75;
otto.intelligenzquotient := 100;

eukaryot := otto; (Zuweisung ist korrekt, das Attribut "intelligenzquotient" wird jedoch nicht zugewiesen)

Zuweisungen ohne Typsicherheit

Programmiersprachen, die für die maschinennahe Programmierung konzipiert wurden, wie zum Beispiel C, haben oft gar keine oder nur eine sehr schwache Typprüfung. Diese Toleranz führt leicht zu Programmfehlern.

Zeiger

In manchen Programmiersprachen, wie zum Beispiel C, ist es erlaubt, beliebige Zeiger einer Zeigervariablen zuzuweisen, ohne dass geprüft wird oder überhaupt geprüft werden kann, ob die Datentypen der referenzierten Daten identisch oder kompatibel sind.

Wahrheitswerte

In einigen älteren Programmiersprachen, wie zum Beispiel C, gibt es keinen eigenen Datentyp für zweiwertige boolesche Variablen. Zur Behandlung und Verarbeitung entsprechender Information wird dann häufig der ganzzahlige Datentyp mit dem kleinsten Speicherbedarf verwendet, wobei der Zahlenwert null für den WahrheitswertFalschund alle anderen Zahlenwerte für den WahrheitswertWahrVerwendung finden. Auch hier ergeben sich logische Inkompatibilitäten und somit Komplikationen, da mit binären Werten keine Arithmetik und mit Zahlen keine logischen Verknüpfungen oder logischen Operationen durchgeführt werden können. Im folgenden Beispiel wird dieser Missbrauch verdeutlicht:

VARIABLE falscheWahrheit1, falscheWahrheit2, ergebnisWahrheit: INTEGER (ganze Zahlen)

falscheWahrheit1 := 0; (0 soll den Wahrheitswert Falsch repräsentieren)
falscheWahrheit2 := 1; (1 soll den Wahrheitswert  Wahr  repräsentieren)

ergebnisWahrheit := falscheWahrheit1 + falscheWahrheit2;   (Ergebnis dieser unsinnigen arithmetischen Addition ist 1,
                                                            was für den Wahrheitswert  Wahr  steht)

ergebnisWahrheit := falscheWahrheit1 UND falscheWahrheit2; (Ergebnis dieser logischen Konjunktion ist 0,
                                                            was für den Wahrheitswert Falsch steht)

ergebnisWahrheit := falscheWahrheit2 + falscheWahrheit2;   (Ergebnis ist 2 und zuweisungskompatibel,
                                                            aber ohne logischen Sinn)

Eine eindeutige und korrekte Implementierung könnte wie folgt aussehen:

VARIABLE richtigeWahrheit1, richtigeWahrheit2, ergebnisWahrheit: BOOLEAN (Wahrheitswerte)

richtigeWahrheit1 := FALSCH; (nur Wahrheitswerte sind zuweisungskompatibel)
richtigeWahrheit2 := WAHR;   (nur Wahrheitswerte sind zuweisungskompatibel)

ergebnisWahrheit := richtigeWahrheit1 UND richtigeWahrheit2; (nur logische Operatoren sind zulässig, und nur Ergebnisse
                                                              mit Wahrheitswerten (hier FALSCH) sind zuweisungskompatibel)

Mengen

Sinngemäß gilt das Gleiche für die Verknüpfungen von Mengen. Wenn hier bei den Datentypen und zulässigen Operatoren nicht zwischen Mengen (englisch = Bitsets) und Zahlen unterschieden wird, kommt es wie zum Beispiel bei der Bestimmung von Differenzmengen zu Interpretationsproblemen:

VARIABLE falscheMenge1, falscheMenge2, differenzMenge: INTEGER (ganze Zahlen)

falscheMenge1 := 0; (0 soll eine leere Menge repräsentieren)
falscheMenge2 := 1; (1 soll eine Menge mit dem Element 1 repräsentieren)

differenzMenge := falscheMenge1 - falscheMenge2; (Ergebnis dieser unsinnigen arithmetischen Subtraktion ist -1)

Eine eindeutige und korrekte Implementierung könnte wie folgt aussehen:

VARIABLE richtigeMenge1, richtigeMenge2, differenzMenge: BITSET (Mengen)

richtigeMenge1 := { }; (soll eine leere Menge repräsentieren)
richtigeMenge2 := {1}; (soll eine Menge mit dem Element 1 repräsentieren)

differenzMenge := richtigeMenge1 - richtigeMenge2; (Nur Mengen-Operatoren sind zulässig,
                                                    und nur Ergebnisse mit Mengen (hier ist das Ergebnis die leere Menge)
                                                    sind zuweisungskompatibel)

Weblinks

  • Stefan Middendorf, Reiner Singer, Jörn Heid: Zuweisungskompatibilität in: Objektorientierte Programmierung mit Java, Die Sprache Java, Programmierhandbuch und Referenz für die JavaTM-2-Plattform, 3. Auflage 2002
  • Uwe Schmidt: Zuweisungskompatibilität in: Objektorientierte Programmierung mit Java, Fachhochschule Wedel

Literatur

Einzelnachweise

  1. Kathleen Jensen, Niklaus Wirth, Andrew B. Mickel: Assignment Statements, in: Pascal user manual and report: ISO Pascal standard, Kapitel 9.1.1, Seite 170, Verlag Springer 1991, ISBN 978-0-3879-7649-5
  2. László Böszörményi, Jürg Gutknecht, Gustav Pomberger: Symbol Table Handling, in: The school of Niklaus Wirth: the art of simplicity, Seiten 61 und 62, Verlag Morgan Kaufmann 2000, ISBN 9781558607231
  3. Joel Pitt: Volition Systems' Modula-2 Programming Language, in: InfoWorld vom 19. September 1983, Band 5, Nummer 38, InfoWorld Media Group, ISSN 0199-6649
  4. Kent Lee: Example 8.2, in: Programming Languages: An Active Learning Approach, Kapitel 8, Seiten 228 und 229, 2008, ISBN 9780387794211

Wikimedia Foundation.

Игры ⚽ Нужен реферат?

Schlagen Sie auch in anderen Wörterbüchern nach:

  • Datentyp — Formal bezeichnet ein Datentyp in der Informatik die Zusammenfassung von Objektmengen mit den darauf definierten Operationen. Dabei werden durch den Datentyp des Datensatzes unter Verwendung einer so genannten Signatur ausschließlich die Namen… …   Deutsch Wikipedia

  • Feld (Datentyp) — Ein Feld (englisch Array [əˈɹeɪ] (Betonung auf 2. Silbe) für ‚Anordnung‘, ‚Aufstellung‘, ‚Reihe‘, ‚Reihung‘, ‚Bereich‘) bezeichnet in der Informatik eine Datenstruktur. Dabei wird zwischen einem Standard Feld und dem assoziativen Array… …   Deutsch Wikipedia

  • Menge (Datenstruktur) — Die Datenstruktur Menge, auch Set genannt, ist eine ungeordnete Sammlung von Elementen eines bestimmten Datentyps, von denen jeweils maximal ein Exemplar enthalten ist. Sie ist der endlichen Menge in der Mathematik nachempfunden. Es ist meist aus …   Deutsch Wikipedia

  • Programmfehler — Ein Programmfehler oder Softwarefehler, häufig auch als Bug (bʌg) benannt, bezeichnet im Allgemeinen ein Fehlverhalten von Computerprogrammen. Dies tritt auf, wenn der Programmierer einen bestimmten Zustand in der Programmlogik beim Umsetzen der… …   Deutsch Wikipedia

  • Starke Typisierung — (engl. strong typing, deutsch oft auch strenge Typisierung) bezeichnet ein Prinzip bei der Typisierung von Programmiersprachen, das allerdings nicht eindeutig definiert ist. In der Fachliteratur finden sich unterschiedlich strenge Definitionen.… …   Deutsch Wikipedia

  • Typumwandlung — Als Typumwandlung (englisch type conversion oder cast) wird in der Informatik die Umwandlung eines Datentyps in einen anderen bezeichnet, um eine Typverletzung zu vermeiden, die durch mangelnde Zuweisungskompatibilität gegeben ist. Hierbei… …   Deutsch Wikipedia

  • Typverletzung — Eine Typverletzung (engl. type conflict) liegt vor, wenn Datentypen zum Beispiel aufgrund fehlender Zuweisungskompatibilität nicht regelgemäß verwendet werden. Zum Beispiel werden Variablen Datentypen zugeordnet, womit ihr Wertebereich, also die… …   Deutsch Wikipedia

  • Zuweisung — Unter einer Zuweisung (engl. assignment) versteht man in einer imperativen Programmiersprache einen Typ von Anweisung (englisch statement), durch den eine Variable einen neuen Wert erhält. In Abgrenzung von anderen Anweisungstypen, die ebenfalls… …   Deutsch Wikipedia

Share the article and excerpts

Direct link
https://de-academic.com/dic.nsf/dewiki/2639400 Do a right-click on the link above
and select “Copy Link”