Get these flashcards, study & pass exams. For free! Even on iPhone/Android!

- Abhängig vom zu lösenden Problem
- Der Leistungsfähigkeit der jeweiligen Hardware

Betrachtet man den Stammbaum der Programmiersprachen so erkennt man, dass viele der Sprachen zueinander verwandt sind und sich in ihrer Entwicklung gegenseitig beeinflusst haben. Auf Grund der unterschiedlichen Anforderungen der Programmierer an die jeweilige Sprache entwickelten sich auch unterschiedliche Sprachen.

Weil "C" einen qualitativen Sprung hinsichtlich des Programmierkomforts liefert, da die Befehle der
Umgangssprache ähneln ("DO..WHILE") => gut wartender und übersichtlicher Code steht an erster Stelle,
da die Kosten für einen Programmierer überwiegen.
Die Sprache liefert zudem kleine, schnelle und portable Programme.
Die Werkzeuge von C++ machen die
Entwicklung von komplexen und leistungsfähigen Anwendungen möglich.
Das ANSI erarbeitet eine eindeutige und maschinenunabhängige Definition der Programmiersprache C, den
ANSI-C-Standard.

In der Gründerzeit arbeiteten die Programmierer mit den primitivsten Computeranweisungen der
Maschinensprache.
Sie kann vom Computer direkt ausgeführt werden und besteht aus einer Abfolge von
den Dualziffern 0/1.
Sie liefert kleine, schnelle Programme die jedoch sehr
fehleranfällig sind.
Sie ist an den Prozessortyp gebunden.
Die Assemblersprache ist etwas anschaulicher, da sie für den Menschen leichter verständliche
"mnemonische" Symbole verwendet. Vorteil hierbei ist der geringe Speicherbedarf und die schnelle
Ausführungszeit. Jedoch verlieren diese Vorteile an Bedeutung, da die Kosten eines Programmierers
überwiegen. Die Programme sind auf die jeweilige Hardware zugeschnitten, somit nur schwer übertragbar
auf andere Rechner.
Übersetzt wird mittels Assemblers in die Maschinensprache.
Die Befehle der Hochsprachen ähneln der Umgangssprache.
Der Code ist leicht zu warten und lässt sich mit
weniger (Kosten)-Aufwand erweitern und verbessern. Die Sprache ist an keine Hardware mehr gebunden,
sie orientiert sich am zu lösenden Problem.

Maschinensprache
+ Kleine, schnelle Programme
- Fehleranfällig
- Funktionen für Menschen schwer ersichtlich
- An Prozessortyp gebunden

Assemblersprache
+ Geringer Speicherbedarf, schnelle Ausführungszeit
- Schwer an andere Computertypen übertragbar
- Kosten für Programmierer übersteigen die der Hardware

Hochsprachen
+ Hoher Programmierkomfort (Ähnlichkeit der Umgangssprache)
+ Qualitativer Sprung
- Rechenleistung
- Speicher"

1. Generation: Maschinensprache
2. Generation: Assemblercode mit seinen leichter verständlichen mnemoischen Anweisungen.
3. Generation: Systemunabhängige Hochsprachen, prozeduraler und problemorientierter Natur. Das zu
lösende Problem steht im Mittelpunkt.
4. Generation: Nonprozedurale Programmiersprachen, die Problembezogenheit tritt in den Hintergrund,
dafür steht die Universalität in den Vordergrund. Es wird beschrieben was das Programm machen soll und
nicht wie. Somit ist keine umfangreiche Programmierausbildung nötig (DELPI, SQL).
5. Generation: Künstliche Intelligenz: Es wird versucht die natürliche Intelligenz des Menschen durch
konstruierte Computer nachzuvollziehen. (PROLOG)
OOP Generation: Objektorientierte Generation, Probleme werden mit verschiedenen Objekten gelöst, Ein
Objekt enthält mit seinen Eigenschaften und Methoden immer alles, was für eine bestimmte Aufgabe
notwendig ist."

Bei der prozeduralen Programmierung stellt man sich Programme als eine Abfolge auszuführender
Anweisungen auf einen Satz von Daten vor.

Mit Hilfe der strukturierten Programmierung bringt man eine Systematik in die Abfolge der Prozeduren und
teilt das Programm in Daten und Funktionen ein.

+ Die strukturierte Programmierung bietet einen erfolgreichen Lösungsansatz bei komplexeren Aufgabenstellungen

- Bei zunehmender Datenmenge wird die Trennung zw. Daten und Prozeduren immer schwieriger

- Die Wiederverwendbarkeit ist zu gering

Virtueller Universalrechner, der aus den 5 Funktionseinheiten: Steuerwerk, Rechenwerk,
Ein und Ausgabewerk sowie Speicher besteht.
Informationen zw. diesen Einheiten werden über Daten, Steuer und Adressbus ausgetauscht.

Imperative Programmiersprachen basieren auf Befehlen. Anpassung an diesen Universalrechner an das
zu lösende Problem, durch aufeinander folgende Befehle, dem Programm.
=> Programme, die auf einem Von-Neumann-Rechner laufen, laufen auf jedem beliebigen Rechner.

Diese gehören auch zur Gruppe der imperativen Programmiersprachen.
Lösen der Probleme durch berechnen von Funktionen.

Der Anwender gibt eine Menge von Fakten und Regeln vor, wie aus Fakten neue Fakten geschaffen
werden können.
Aufgabe des Rechners ist, mit richtig oder falsch zu antworten.

Imperative basieren auf Befehlen,
deklarative orientieren sich an der Aussage.

Kapselung bedeutet, dass alle Eigenschaften und Funktionen die von dem Objekt ausgeführt
werden, in der Definition des Objekts enthalten sind (HDD).

In der objektorientierten Programmierung ist es nicht notwendig, dass der Benutzer eines Objekts die Funktionsweisen aller Daten und Methoden eines Objekts kennt.
Er muss sie nur anwenden können.
Die Daten sind vor ihm verborgen.
In C++ muss der Benutzer nicht wissen wie eine Klasse funktioniert, er muss sie nur anwenden können."

Vererbung bedeutet, dass ein Objekt auf den Eigenschaften eines anderen Objekts aufbauen kann.
Es erbt die Eigenschaften und Methoden des Basisobjekts."

Polymorphie bedeutet vielgestaltig,
viele Objekte können dieselbe Methode verwenden und unternehmen genau dann die richtigen Schritte, um die Funktion auszuführen.
Sie interpretieren die Nachricht, abhängig
von der Verwendung, unterschiedlich.

Wiederverwendbarkeit ist wichtig, weil es Zeit und Geld spart, Stabilität bringt und eine Verbesserung/
Weiterentwicklung möglich macht.

"Klasse = Bauplan
Objekt = Komponenten!! Falsch!
Eigenschaften = Attribute
Methode = Funktionen
Programme aus einzelnen Objekten mit bekannten Eigenschaften und Methoden können nach Bedarf
zusammengestellt werden.
Die Klasse entspricht dabei dem Bauplan eines konkreten Objekts.
So muss man die einzelnen Komponenten nicht immer neu erfinden, sondern fügt sie entsprechend zusammen.

Assemblercode ist manschinennah, mnemotechnisch aufgebaut und wird in Maschinensprache
assembliert.

Compilierte Sprachen werden am Stück in selbstständige, lauffähige Programme übersetzt (bezogen auf
OS).

Skriptsprachen werden zur Laufzeit übersetzt (Schritt für Schritt). Zur Ausführung wird ein Shell oder Wirtprogramm benötigt.

Compiler: C, C++, COBOL, Smaltalk, Pacal

Interpreter: VBA, Perl, PHP, JavaScript

keine Einteilung: HTML/XML (Seitenbeschreibungs- bzw. Strukturbeschreibungssprache),
JAVA (wird mit Compiler in Bytecode übersetzt – benötigt Java VM zur Ausführung),
C#, VB.NET (Microsoft.NET Sprachen – werden in MSIL compiliert – benötigen zur Ausführung JiTCompiler)"

Compiler: C, C++, COBOL, Smaltalk, Pacal
Interpreter: VBA, Perl, PHP, JavaScript

Programme werden unabhängig vom darunter liegendem Betriebssysteme ausgeführt = Maschinenunabhängig.
Der compilierte Bytecode benötigt zur Ausführung aber eine Java-Virtual Machine(JVM).
Java-Virtual-Machine gibt es für verschiedene Plattformen.

Alle .NET Sprachen werden durch einen Sprachcompiler in die MSIL (MS Intermediate Language)
compiliert und benötigen zur Ausführung den JIT-Compiler des .NET Frameworks. Daher können beliebige
MSIL-Code Module („Assemblies“) unterschiedlicher .NET Programmiersprachen kombiniert werden.

Ein Algorithmus ist eine Reihenfolge von Anweisungen zur Lösung eines Problems in einer bestimmten
Programmiersprache.

Abstraktion = eine Art Unterprogramm in einem Algorithmus. Man „ruft“ das Programm nur mit seinem
Namen auf, meint damit aber eine ganze Reihe von konkreten Anweisungen.

Ein Programm ist ein Weg zum Lösen eines Problems.
Es besteht aus einer genauen Folge von Anweisungen.

Unter Softwaretechnik versteht man, den Entwurf und die Entwicklung von Software-Systemen
einschließlich Dokumentation und widerverwendbaren Komponenten.

In einer Programmbibliothek werden wiederverwendbare Softwarekomponenten abgelegt. Es ist zu teuer
das Rad jedes Mal neu zu erfinden, darum greift man auf die PB zurück.

Der TLE löst das Problem auf einer sehr allgemeinen Ebene. Hier werden die einzelnen Komponenten,
aus denen sich das Programm zusammensetzt, aufgeschlüsselt (Teambildung, Teamarbeit).

Jede einzelne Komponente eines Softwaresystems durchläuft die
3 Phasen:
Entwurf, Implementierung (das
eigentliche Programm schreiben) und Test. Erst wenn der Komponententest erfolgreich abgeschlossen ist
können die Komponenten zusammengefügt werden.

Bei der Systemintegration werden die getesteten Einzelkomponenten des Softwaresystems
zusammengefügt, hier wird geprüft ob die einzelnen Komponenten auch zusammen funktionieren.

z.B. zwei Datenbanken, die als einzelne funktionieren müssen nicht unbedingt zusammen funktionieren.
Dabei können Fehler beim laden der Daten oder beim Speichern auftauchen.

Ein konkreter Entwurf spart Zeit und Entwicklungskosten, da eine Änderung am Entwurf einfach
durchzuführen ist, als Änderungen nach dem Komponententest oder Systemtest.

Es ist sehr umständlich Vorgehensweisen vollständig schriftlich festzuhalten, darum werden die
Algorithmen in einer bestimmten Art und Weise notiert.
Kein „go to“, Dokumentation, klarer Ablauf

Der Bedarf nach einem Struktorgramm richtet sich nach der Größe des Projekts und aus der
Aufgabenstellung.

Kopfgesteuerte Schleife:
Abfrage der Bedingung erfolgt vor der Durchführung der Verarbeitung. Ist die Bedingung bei der ersten
Abfrage schon nicht erfüllt, erfolgt keine Durchführung der Verarbeitung (While-Schleife).

Fußgesteuerte Schleife:
Abfrage der Bedingung nach dem Durchlauf der Verabeitung (Repeat-Schleife). Die Schleife läuft also
mindestens einmal durch. ( DO ... WHILE)

Compiler liest Quelltextdateien (.cpp; .h) und erzeugt einen Zwischencode (.obj; .lib).
Der Linker verbindet diese Komponenten und erstellt *.exe.

Aufbau besteht aus einer hierarchischen Struktur von Knoten (wie Explorer).
Oberster Knoten ist die Solution (Projektmappe), untergeordnet sind mehrere Projektknoten, wobei mehrere
Projekte immer innerhalb einer Projektmappe verwaltet werden können.

Alle Quelldateien eines Projektes werden auf einmal in der richtigen Reihenfolge kompiliert und gelinkt.
Einfacher für den Compiler/Linker, da nur eine „main“.

include (engl: einbinden) ist eine Präprozessor-Anweisung und bedeutet: Suche die Datei in den spitzen
Klammern und setzte sie genau an der Stelle im Programm ein. („Suchen/Ersetzten-Maschine“)

Jedes C++ Programm enthält genau eine „main“ Funktion, die beim Programmstart automatisch
aufgerufen wird. Alles zw. {} ist die Hauptfunktion bzw. das eigentliche Programm.

// = Bis zum Zeilenende
/* */ = Über mehrere Zeilen

Zur eigenen (bzw. für andere) Orientierung/Verständnis bzw. Notizen zu hinterlegen.

Deklaration: Speicherplatz wird reserviert
double radius  Name = radius, Typ = double

Initialisierung: Wert wird zugewiesen
radius = 20  = ist der Zuweisungsoperator

short
int
long
float
double
char

char      = 1 Byte
int         = 4 Byte
float      = 4 Byte
double = 8 Byte

literal: Wert wird an der Stelle des Vorkommens eingetippt.
Man kann diesen Wert dann nicht mehr verändern.

symbolisch: hat einen Namen (PI), allerdings lässt sich der Wert nach der Definition nicht mehr ändern.
So braucht man nicht immer 3,14159 schreiben,
denn es reicht auch PI.

Funktionskopf (Prototyp) – Deklaration -> in die Headerdatei
Rückgabetyp Bezeichner (Parametertyp Parameter)
Beispiel:
double Quadrat (double seite);

Funktionsrumpf – Definition -> in die Quelltextdatei
Beispiel:
double Quadrat (double seite)
{
return seite * seite ;
}

Im Hauptprogramm ruft man Funktionen mit dem Namen und den Übergabeparametern auf.
Addiere(4,35);
4 und 35 werden an die Funktion Addiere übergeben, die Programmausführung springt in den
Funktionsrumpf von Addiere.

- Prototyp vor dem ersten Gebrauch – normal Headerdatei
- Definition, egal – nur nicht in eine andere Definition