Imperative Programmierung

Im Informatik, Imperative Programmierung ist ein Programmierparadigma von Software das verwendet Aussagen das ändert die eines Programms Zustand. In ähnlicher Weise wie die Imperative Stimmung in natürliche Sprachen Ausdrücken Befehle, ein imperatives Programm besteht aus Befehle für die Computer aufführen. Imperative Programmierung konzentriert sich auf die Beschreibung wie Ein Programm arbeitet Schritt für Schritt und nicht auf hochrangige Beschreibungen seiner erwarteten Ergebnisse.

Der Begriff wird oft im Gegensatz zu verwendet deklarative Programmierungdas konzentriert sich auf was Das Programm sollte erreicht werden, ohne alle Details anzugeben wie Das Programm sollte das Ergebnis erzielen.[1]

Imperative und prozedurale Programmierung

Verfahrensprogrammierung ist eine Art imperative Programmierung, in der das Programm aus einem oder mehreren Verfahren erstellt wird (auch als bezeichnet Unterroutinen oder Funktionen). Die Begriffe werden häufig als Synonyme verwendet, aber die Verwendung von Verfahren hat dramatische Auswirkungen darauf, wie zwingende Programme aussehen und wie sie konstruiert werden. Starke prozedurale Programmierung, in dem Zustand Änderungen sind in Verfahren lokalisiert oder auf explizite Argumente und Rückgaben aus den Verfahren beschränkt, ist eine Form von Strukturierte Programmierung. Ab den 1960er Jahren strukturierte Programmierung und Modulare Programmierung Im Allgemeinen wurden als Techniken zur Verbesserung der Förderung der Wartbarkeit und allgemeine Qualität der imperativen Programme. Die Konzepte dahinter Objekt orientierte Programmierung Versuchen Sie, diesen Ansatz zu verlängern.

Verfahrensprogrammierung könnte als Schritt in Richtung deklarativer Programmierung angesehen werden. Ein Programmierer kann oft erkennen, indem sie sich nur die Namen, Argumente und Rückgabetypen (und verwandte Kommentare) ansehen, was ein bestimmtes Verfahren bewirken soll, ohne unbedingt die Details zu betrachten, wie er sein Ergebnis erzielt. Gleichzeitig ist ein vollständiges Programm immer noch unabdingbar, da es Korrekturen Die Aussagen, die ausgeführt werden sollen, und ihre Ausführungsreihenfolge in hohem Maße.

Begründung und Grundlagen der imperativen Programmierung

Das Programmierparadigma zum Erstellen von Programmen für fast alle Computer folgt normalerweise einem imperativen Modell.[Anmerkung 1] Digitale Computerhardware dient zur Ausführung Maschinensprache, die am Computer beheimatet ist und normalerweise im imperativen Stil geschrieben ist, obwohl für einige Architekturen wie bei anderen Paradigmen wie niedrige Compiler und Dolmetscher wie andere Paradigmen existieren, z. Lisp -Maschinen.

Aus dieser Sicht auf niedriger Ebene wird der Programmzustand durch den Speicherinhalt definiert, und die Aussagen sind Anweisungen in der nativen Maschinensprache des Computers. Imperative Sprachen auf höherer Ebene verwenden Variablen und komplexere Aussagen, folgen aber immer noch dem gleichen Paradigma. Rezepturen und Prozess Checklistenzwar nicht Computerprogramme, sind auch bekannte Konzepte, die im Stil ähnlich sind wie imperativen Programmieren; Jeder Schritt ist eine Anweisung und die physische Welt hält den Staat. Da die grundlegenden Ideen der imperativen Programmierung sowohl konzeptionell vertraut als auch direkt in der Hardware verkörpert sind, befinden sich die meisten Computersprachen im imperativen Stil.

ZuweisungsanweisungenFühren Sie im imperativen Paradigma einen Vorgang über Informationen im Speicher durch und speichern Sie die Ergebnisse in Speicher für die spätere Verwendung. Imperative Sprachen auf hoher Ebene erlauben zusätzlich die Auswertung von Komplex Ausdrücke, was aus einer Kombination von bestehen kann Rechenoperationen und Funktion Bewertungen und die Zuordnung des resultierenden Wertes zum Speicher. Schleifenaussagen (wie in während Schleifen, machen während der Loops, und für Schleifen) Ermöglichen Sie, dass eine Abfolge von Aussagen mehrmals ausgeführt werden kann. Schleifen können entweder die Anweisungen ausführen, die eine vordefinierte Häufigkeit enthalten, oder sie können sie wiederholt ausführen, bis eine Bedingung erfüllt ist. Bedingt Verzweigung Anweisungen ermöglichen es, eine Abfolge von Anweisungen nur auszuführen, wenn eine Bedingung erfüllt ist. Andernfalls werden die Aussagen übersprungen und die Ausführungssequenz wird von der folgenden Anweisung fortgesetzt. Mit bedingungslosen Verzweigungsanweisungen ermöglichen es, dass eine Ausführungssequenz in einen anderen Teil eines Programms übertragen wird. Dazu gehören der Sprung (genannt gehe zu in vielen Sprachen),, Schalterund das Subprogramm, Subroutine, oder Verfahrensanruf (der normalerweise nach dem Anruf zur nächsten Anweisung zurückkehrt).

Früh in der Entwicklung von hochrangige Programmiersprachendie Einführung der Block ermöglichte den Bau von Programmen, bei denen eine Gruppe von Aussagen und Erklärungen so behandelt werden konnte, als wäre sie eine Erklärung. Dies zusammen mit der Einführung von Unterroutinen, ermöglichte es, komplexe Strukturen durch hierarchische Zerlegung in einfachere prozedurale Strukturen auszudrücken.

Viele imperative Programmiersprachen (wie z. Forran, BASIC, und C) sind Abstraktionen von Montagesprache.[2]

Geschichte der imperativen und objektorientierten Sprachen

Die frühesten imperativen Sprachen waren die Maschinensprachen der ursprünglichen Computer. In diesen Sprachen waren die Anweisungen sehr einfach, was die Hardware -Implementierung erleichterte, aber die Erstellung komplexer Programme behinderte. Forran, entwickelt von John Backus bei Internationale Geschäftsmaschinen (IBM) Ab 1954 war die erste große Programmiersprache, die die Hindernisse entfernen, die durch den Maschinencode bei der Erstellung komplexer Programme vorgestellt wurden. Forran war a kompilierte Sprache Das ermöglichte benannte Variablen, komplexe Ausdrücke, Unterprogramme und viele andere Merkmale, die jetzt in imperativen Sprachen üblich sind. In den nächsten zwei Jahrzehnten wurden viele andere wichtige imperative Programmiersprachen auf hoher Ebene entwickelt. In den späten 1950er und 1960er Jahren,, Algol wurde entwickelt, um mathematische Algorithmen leichter zum Ausdruck zu bringen und sogar als die zu dienen BetriebssystemZielsprache für einige Computer. MUMPS (1966) trugen das imperative Paradigm . Cobol (1960) und BASIC (1964) waren beide Versuche, die Programmiersyntax eher wie Englisch aussehen zu lassen. In den 1970ern, Pascal wurde entwickelt von Niklaus Wirth, und C wurde von Dennis Ritchie Während er arbeitete bei Glockenlabors. Wirth ging weiter zum Design Modula-2 und Oberon. Für die Bedürfnisse der Verteidigungsministerium der Vereinigten Staaten, Jean Ichbiah and a team at Honeywell begann zu entwerfen Ada 1978 nach einem 4-jährigen Projekt zur Definition der Anforderungen für die Sprache. Die Spezifikation wurde erstmals 1983 mit Überarbeitungen in den Jahren 1995, 2005 und 2012 veröffentlicht.

Die 1980er Jahre verzeichneten ein schnelles Interesse an Interesse an Objekt orientierte Programmierung. Diese Sprachen waren stilvoll unerlässlich, fügten jedoch Funktionen hinzu, um sie zu unterstützen Objekte. In den letzten zwei Jahrzehnten des 20. Jahrhunderts wurde vieler solcher Sprachen entwickelt. Smalltalk-80, ursprünglich konzipiert von Alan Kay 1969 wurde 1980 vom Xerox Palo Alto Research Center (veröffentlichtParc). Zeichnen von Konzepten in einer anderen objektorientierten Sprache-Simula (was als erste der Welt angesehen wird objektorientierte Programmiersprache, entwickelt in den 1960er Jahren) -Bjarne Stroustrup entworfen C ++, eine objektorientierte Sprache basierend auf C. Design von C ++ begann 1979 und die erste Umsetzung wurde 1983 abgeschlossen. In den späten 1980er und 1990er Jahren waren die bemerkenswerten imperativen Sprachen auf objektorientierte Konzepte, Perl, veröffentlicht von Larry Wall 1987; Python, veröffentlicht von Guido van Rossum in 1990; Visual Basic und Visuell c ++ (was beinhaltet Microsoft Foundation Class Library (MFC) 2.0), freigegeben von von Microsoft in den Jahren 1991 bzw. 1993; Php, veröffentlicht von Rasmus Lerdorf 1994; Java, durch James Gosling (Sun Microsystems) im Jahr 1995, JavaScript, durch Brendan Eich (Netscape), und Rubin, von Yukihiro "Matz" Matsumoto, beide 1995 veröffentlicht. Microsoft's .NET Framework (2002) ist in seinem Kern unerlässlich, ebenso wie die Hauptzielsprachen. Vb.net und C# das läuft darauf; Jedoch Microsoft F#, eine funktionale Sprache, läuft auch darauf.


Beispiele

Forran

Forran (1958) wurde als "die IBM Mathematical Formel übers System" enthüllt. Es wurde für wissenschaftliche Berechnungen ohne Saite Handhabungseinrichtungen. Zusammen mit Erklärungen, Ausdrücke, und Aussagen, es unterstützte:

Es gelang es, weil:

  • Programmier- und Debugging -Kosten lagen unter den Computerausführungskosten.
  • Es wurde von IBM unterstützt.
  • Anwendungen zu dieser Zeit waren wissenschaftlich.[3]

Nicht -IBM -Anbieter schrieb jedoch auch Forran Compiler, aber mit einer Syntax, die wahrscheinlich den Compiler von IBM nicht bestehen würde.[3] Das American National Standards Institute (ANSI) entwickelte 1966 den ersten FORTRAN -Standard. 1978 wurde Fortran 77 bis 1991 zum Standard. Forran 90 unterstützt:

Cobol

Cobol (1959) steht für "gemeinsame geschäftsorientierte Sprache". Forran manipulierte Symbole. Es wurde bald erkannt, dass Symbole keine Zahlen sein mussten, also wurden Saiten eingeführt.[4] Das US -Verteidigungsministerium Beeinflussen Cobols Entwicklung mit Grace Hopper ein großer Beitrag zu sein. Die Aussagen waren englischartig und ausführlich. Ziel war es, eine Sprache zu entwerfen, damit Manager die Programme lesen konnten. Das Fehlen strukturierter Aussagen behinderte jedoch dieses Ziel.[5]

Die Entwicklung von COBOL wurde eng kontrolliert, sodass Dialekte nicht entstanden waren, um ANSI -Standards zu erfordern. Infolge Objekt orientierte Programmierung.[5]

Algol

Algol (1960) steht für "algorithmische Sprache". Es hatte einen tiefgreifenden Einfluss auf das Programmiersprache.[6] Es stand aus einem Ausschuss europäischer und amerikanischer Programmiersprachenexperten, verwendete Standard -mathematische Notation und hatte ein lesbares strukturiertes Design. Algol definierte als Erster seine Syntax Verwendung der Backus -Naur -Form.[6] Dies führte zu Syntax-inszeniert Compiler. Es fügte Funktionen hinzu wie:

Zu den direkten Nachkommen von Algol gehören Pascal, Modula-2, Ada, Delphi und Oberon auf einem Zweig. Auf einer anderen Niederlassung gibt es C, C ++ und Java.[6]

Basic

BASIC (1964) steht für "Anfänger -symbolischer Anweisungscode" Anfänger ". Es wurde bei entwickelt bei Dartmouth College für alle ihre Schüler lernen.[7] Wenn ein Schüler nicht zu einer mächtigeren Sprache ging, würde sich der Schüler noch an Basic erinnern.[7] Ein grundlegender Dolmetscher wurde in der installiert Mikrocomputer Ende der 1970er Jahre hergestellt. Als die Mikrocomputerindustrie wuchs, auch die Sprache.[7]

Grundlegende Pionierarbeit die interaktive Sitzung.[7] Es bot an Betriebssystem Befehle in seiner Umgebung:

  • Der Befehl "neu" erstellte einen leeren Schiefer.
  • Aussagen sofort bewertet.
  • Aussagen könnten durch die Vorgehensweise mit einer Zeilennummer programmiert werden.
  • Der Befehl 'List' zeigte das Programm an.
  • Der Befehl "Run" wurde das Programm ausgeführt.

Die grundlegende Syntax war jedoch für große Programme zu einfach.[7] Neuere Dialekte haben Struktur und objektorientierte Erweiterungen hinzugefügt. Microsoft's Visual Basic wird immer noch weit verbreitet und produziert a grafische Benutzeroberfläche.[8]

C

C Programmiersprache (1973) haben seinen Namen, weil die Sprache BCPL wurde ersetzt durch B, und AT & T Bell Labs genannt die nächste Version "C." Sein Ziel war es, die zu schreiben Unix Betriebssystem.[9] C ist eine relativ kleine Sprache - so einfach, Compiler zu schreiben. Das Wachstum spiegelte das Hardwarewachstum in den 1980er Jahren wider.[9] Sein Wachstum war auch, weil es die Einrichtungen von hat Montagesprache, verwendet aber a hochrangige Syntax. Es fügte erweiterte Funktionen hinzu wie:

Computerspeicherkarte

C Ermöglicht dem Programmierer, zu steuern, welcher Bereich der Speicherdaten gespeichert werden soll. Globale Variablen und Statische Variablen die wenigsten benötigen Taktzyklen lagern. Das Stapel wird automatisch für die Standardvariable verwendet Erklärungen. Haufen Speicher wird an a zurückgegeben Zeigervariable von dem malloc () Funktion.

  • Das globale und statische Daten Region liegt knapp über der Programm Region. (Die Programmregion wird technisch als die genannt Text Region. Hier werden Maschinenanweisungen gespeichert.)
  • Die globale und statische Datenregion beträgt technisch gesehen zwei Regionen.[10] Eine Region heißt die initialisiert Datensegment, wobei Variablen, die mit Standardwerten deklariert sind, gespeichert werden. Die andere Region heißt die Block gestartet vom Segment, wo Variablen ohne Standardwerte deklariert werden.
  • Variablen in der gespeicherten globale und statische Daten Region haben ihre Adressen auf Compile-Zeit einstellen. Sie behalten ihre Werte während des gesamten Lebens des Prozesses.
  • Die globale und statische Region speichert die globale Variablen das werden über (außerhalb) deklariert hauptsächlich() Funktion.[11] Globale Variablen sind sichtbar für hauptsächlich() und jede andere Funktion im Quellcode.
Andererseits variable Erklärungen innerhalb von von hauptsächlich(), andere Funktionen oder innerhalb { } Block -Abgrenzer sind Lokale Variablen. Lokale Variablen umfassen ebenfalls auch formaler Parameter Variablen. Parametervariablen sind in die Klammern von Funktionsdefinitionen eingeschlossen.[12] Sie liefern eine Schnittstelle zur Funktion.
  • Lokale Variablen mit dem deklariert statisch Präfix werden auch in der gespeichert globale und statische Daten Region.[10] Im Gegensatz zu globalen Variablen sind statische Variablen nur innerhalb der Funktion oder des Blocks sichtbar. Statische Variablen behalten immer ihren Wert. Eine Beispielnutzung wäre die Funktion int increment_counter () {static int counter = 0; Zähler ++; Rückkehrzähler;}
  • Das Stapel Region ist ein zusammenhängender Speicherblock in der Nähe der oberen Speicheradresse.[13] Variablen, die in den Stapel platziert sind, werden ironischerweise von oben nach unten besiedelt.[13] A Stapelzeiger ist ein Spezialzweck registrieren Das verfolgt die letzte Speicheradresse.[13] Variablen werden über die Stapel in den Stapel gegeben Montagesprache Anweisung drücken. Daher werden die Adressen dieser Variablen während festgelegt Laufzeit. Die Methode für Stapelvariablen, um ihre zu verlieren Umfang ist über die Pop -Anweisung.
  • Lokale Variablen ohne die deklariert statisch Präfix, einschließlich formaler Parametervariablen,[14] werden genannt Automatische Variablen[11] und werden im Stapel aufbewahrt.[10] Sie sind in der Funktion oder im Block sichtbar und verlieren ihren Geltungsbereich, wenn sie die Funktion oder den Block verlassen.
  • Das Haufen Die Region befindet sich unter dem Stapel.[10] Es ist von unten nach oben besiedelt. Das Betriebssystem verwaltet den Haufen mit a Haufenzeiger und eine Liste der zugewiesenen Speicherblöcke.[15] Wie der Stack werden die Adressen von HAVE -Variablen während der Laufzeit festgelegt. Ein aus dem Gedächtnis Fehler tritt auf, wenn sich der Haufenzeiger und der Stapelzeiger treffen.
  • C Bietet die malloc () Bibliotheksfunktion zu zuweisen Heap -Speicher.[16] Das Ausfüllen des Heaps mit Daten ist eine zusätzliche Kopienfunktion. Variablen, die im Haufen gespeichert sind, werden wirtschaftlich an Funktionen unter Verwendung von Zeigern übergeben. Ohne Hinweise müsste der gesamte Datenblock über den Stapel an die Funktion übergeben werden.

C ++

In den 1970ern, Software -Ingenieure benötigte Sprachunterstützung, um große Projekte in die Abteilung zu bringen Module.[17] Ein offensichtliches Merkmal bestand darin, große Projekte zu zersetzen physisch in getrennte Dateien. Ein weniger offensichtliches Merkmal bestand darin, große Projekte zu zersetzen logisch hinein abstrakt Datentypen.[17] Zu dieser Zeit unterstützten Sprachen Beton (Skalar) Datenatypen wie ganze Zahl Zahlen, Schwimmpunkt Zahlen und Saiten von Figuren. Konkrete Datentypen haben ihre Darstellung als Teil ihres Namens.[18] Abstrakte Datentypen sind Strukturen von konkreten Datentypen - mit einem neuen Namen zugewiesen. Zum Beispiel a aufführen von Ganzzahlen könnte genannt werden INTEGER_LIST.

In objektorientiertem Jargon werden abstrakte Datenatypen aufgerufen Klassen. Allerdings a Klasse ist nur eine Definition; Es wird kein Gedächtnis zugewiesen. Wenn eine Speicherin an eine Klasse zugeordnet wird, wird es als eine genannt Objekt.[19]

Objektorientierte imperative Sprachen entwickelt durch Kombination der Notwendigkeit von Klassen und der Notwendigkeit eines Safe Funktionelle Programmierung.[20] Eine Funktion in einer objektorientierten Sprache wird einer Klasse zugeordnet. Eine zugewiesene Funktion wird dann als als bezeichnet Methode, Mitgliedsfunktion, oder Betrieb. Objekt orientierte Programmierung führt aus Operationen an Objekte.[21]

Objektorientierte Sprachen Unterstützen Sie eine Syntax zum Modellieren Untergruppe/Superset Beziehungen. Im Mengenlehre, ein Element einer Untergruppe erbt alle in der Superset enthaltenen Attribute. Zum Beispiel ist ein Schüler eine Person. Daher ist die Gruppe der Schüler eine Teilmenge der Personenmenge. Infolgedessen erben die Schüler alle Attribute, die allen Personen gemeinsam sind. Darüber hinaus haben die Schüler einzigartige Attribute, die andere Personen nicht haben. Objektorientierte Sprachen Modell Untergruppe/Superset Beziehungen verwenden Nachlass.[22] Objekt orientierte Programmierung wurde Ende der neunziger Jahre zum dominanten Sprachparadigma.[17]

C ++ (1985) wurde ursprünglich "C mit Klassen" bezeichnet.[23] Es wurde entwickelt, um sich zu erweitern C's Fähigkeiten durch Hinzufügen der objektorientierten Einrichtungen der Sprache Simula.[24]

Ein objektorientiertes Modul besteht aus zwei Dateien. Die Definitionsdatei wird als die Datei bezeichnet Header-Datei. Hier ist ein C ++ Header-Datei für die Klassenklasse In einer einfachen Schulanwendung:

// grade.h // ------- // wird verwendet, um mehrere Quelldateien einzuschließen zu lassen // Diese Header -Datei ohne Duplizierungsfehler. // ---------------------------------------------- #IFNDEF GRADE_H #define grade_h Klasse KLASSE { Öffentlichkeit:   // Dies ist der Konstruktorbetrieb.   // ----------------------------------   KLASSE ( Const verkohlen Buchstabe );   // Dies ist eine Klassenvariable.   // -------------------------   verkohlen Buchstabe;   // Dies ist eine Mitgliedsoperation.   // ---------------------------   int grade_numeric( Const verkohlen Buchstabe );   // Dies ist eine Klassenvariable.   // -------------------------   int numerisch; }; #endif

A Konstrukteur Die Operation ist eine Funktion mit demselben Namen wie der Klassenname.[25] Es wird ausgeführt, wenn der aufrufende Betrieb die ausführt Neu Aussage.

Die andere Datei eines Moduls ist die Quelldatei. Hier ist eine C ++ - Quelldatei für die Klassenklasse In einer einfachen Schulanwendung:

// grade.cpp // --------- #enthalten "grade.h" KLASSE::KLASSE( Const verkohlen Buchstabe ) {   // Referenz auf das Objekt mit dem Schlüsselwort 'This'.   // ----------------------------------------------   Dies->Buchstabe = Buchstabe;   // Dies ist der zeitliche Zusammenhalt   // -------------------------   Dies->numerisch = grade_numeric( Buchstabe ); } int KLASSE::grade_numeric( Const verkohlen Buchstabe ) {   wenn ( ( Buchstabe == 'EIN' || Buchstabe == 'a' ) )   Rückkehr 4;   anders   wenn ( ( Buchstabe == 'B' || Buchstabe == 'b' ) )   Rückkehr 3;   anders   wenn ( ( Buchstabe == 'C' || Buchstabe == 'c' ) )   Rückkehr 2;   anders   wenn ( ( Buchstabe == 'D' || Buchstabe == 'd' ) )   Rückkehr 1;   anders   wenn ( ( Buchstabe == 'F' || Buchstabe == 'f' ) )   Rückkehr 0;   anders   Rückkehr -1; }

Hier ist ein C ++ Header-Datei für die Personklasse In einer einfachen Schulanwendung:

// Person.h // -------- #ifndef person_h #define Person_h Klasse PERSON { Öffentlichkeit:   PERSON ( Const verkohlen *Name );   Const verkohlen *Name; }; #endif

Hier ist ein C ++ Quelldatei für die Personklasse In einer einfachen Schulanwendung:

// Person.cpp // ---------- #enthalten "Person.h" PERSON::PERSON ( Const verkohlen *Name ) {   Dies->Name = Name; }

Hier ist ein C ++ Header-Datei für die Schülerklasse In einer einfachen Schulanwendung:

// student.h // --------- #ifndef student_h #define student_h #enthalten "Person.h" #enthalten "grade.h" // Ein Schüler ist eine Teilmenge von Person. // -------------------------------- Klasse SCHÜLER : Öffentlichkeit PERSON{ Öffentlichkeit:   SCHÜLER ( Const verkohlen *Name );   KLASSE *Klasse; }; #endif

Hier ist ein C ++ Quelldatei für die Schülerklasse In einer einfachen Schulanwendung:

// student.cpp // ----------- #enthalten "Student.h" #enthalten "Person.h" SCHÜLER::SCHÜLER ( Const verkohlen *Name ):   // Führen Sie den Konstruktor der Person Superklasse aus.   // -------------------------------------------------   PERSON( Name ) {   // Nichts weiter zu tun.   // ------------------- }

Hier ist ein Treiberprogramm zur Demonstration:

// student_dvr.cpp // --------------- #enthalten  #enthalten "Student.h" int hauptsächlich( Leere ) {   SCHÜLER *Schüler = Neu SCHÜLER( "Der Student" );   Schüler->Klasse = Neu KLASSE( 'a' );   std::Cout    // Beachten Sie, dass der Schüler den Namen der Person erbt   << Schüler->Name   << ": Numerische Klasse ="   << Schüler->Klasse->numerisch   << "\n"; 	Rückkehr 0; }

Hier ist ein Makefile Alles kompilieren:

# Makefile # -------- alle: student_dvr sauber:     rm student_dvr *.ostudent_dvr: student_dvr.CPP Klasse.o Schüler.o Person.o     c ++ student_dvr.cpp grade.o student.o person.o -o student_dvrgrade.o: Klasse.CPP Klasse.h     c ++ -c Grad.cppStudent.O: Schüler.CPP Schüler.h     c ++ -c student.cppPerson.o: Person.CPP Person.h     c ++ -c Person.cpp

Siehe auch

Anmerkungen

  1. ^ Rekonfigurierbares Computer ist eine bemerkenswerte Ausnahme.

Verweise

  1. ^ "Imperative Programmierung: Überblick über das älteste Programmierparadigma". Ionos digitalguide. Abgerufen 2022-05-03.
  2. ^ Bruce Eckel (2006). In Java denken. Pearson Ausbildung. p. 24. ISBN 978-0-13-187248-6.
  3. ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 16. ISBN 0-201-71012-9.
  4. ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 24. ISBN 0-201-71012-9.
  5. ^ a b Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 25. ISBN 0-201-71012-9.
  6. ^ a b c d Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 19. ISBN 0-201-71012-9.
  7. ^ a b c d e Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 30. ISBN 0-201-71012-9.
  8. ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 31. ISBN 0-201-71012-9.
  9. ^ a b c Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 37. ISBN 0-201-71012-9.
  10. ^ a b c d "Speicherlayout von C -Programmen". 12. September 2011.
  11. ^ a b Kernighan, Brian W.; Ritchie, Dennis M. (1988). Die C -Programmiersprache zweite Ausgabe. Prentice Hall. p. 31. ISBN 0-13-110362-8.
  12. ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 128. ISBN 0-201-71012-9.
  13. ^ a b c Kerrisk, Michael (2010). Die Linux -Programmierschnittstelle. Keine Stärkepresse. p. 121. ISBN 978-1-59327-220-3.
  14. ^ Kerrisk, Michael (2010). Die Linux -Programmierschnittstelle. Keine Stärkepresse. p. 122. ISBN 978-1-59327-220-3.
  15. ^ Kernighan, Brian W.; Ritchie, Dennis M. (1988). Die C -Programmiersprache zweite Ausgabe. Prentice Hall. p. 185. ISBN 0-13-110362-8.
  16. ^ Kernighan, Brian W.; Ritchie, Dennis M. (1988). Die C -Programmiersprache zweite Ausgabe. Prentice Hall. p. 187. ISBN 0-13-110362-8.
  17. ^ a b c Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 38. ISBN 0-201-71012-9.
  18. ^ Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 65. ISBN 978-0-321-56384-2.
  19. ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 193. ISBN 0-201-71012-9.
  20. ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 39. ISBN 0-201-71012-9.
  21. ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 35. ISBN 0-201-71012-9.
  22. ^ Wilson, Leslie B. (2001). Vergleichende Programmiersprachen, dritte Ausgabe. Addison-Wesley. p. 192. ISBN 0-201-71012-9.
  23. ^ Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 22. ISBN 978-0-321-56384-2.
  24. ^ Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 21. ISBN 978-0-321-56384-2.
  25. ^ Stroustrup, Bjarne (2013). Die C ++ - Programmiersprache, vierte Ausgabe. Addison-Wesley. p. 49. ISBN 978-0-321-56384-2.
  • Pratt, Terrence W. und Marvin V. Zelkowitz. Programmiersprachen: Design und Implementierung, 3. Aufl. Englewood Cliffs, N.J.: Prentice Hall, 1996.
  • Sebesta, Robert W. Konzepte von Programmiersprachen, 3. Aufl. Reading, Mass.: Addison-Wesley Publishing Company, 1996.
Ursprünglich basierend auf dem Artikel 'Imperative Programmierung' von Stan Seibert, von Nupedia, lizenziert unter dem GNU kostenlose Dokumentationslizenz.