Hol' Dir diese Lernkarten, lerne & bestehe Prüfungen. Kostenlos! Auch auf iPhone/Android!

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

- liefert Programmierkomfort, da die Befehle der Umgangssprache ähneln
- gut wartender und übersichtlicher Code
- kleine, schnelle und portable Programme
- Entwicklung von komplexen und leistungsfähigen Anwendungen
- ANSI-C-Standard (eindeutige, maschinenunabhängige Definition)

Maschinensprache:
- kann vom Computer direkt ausgeführt werden
- Dualziffern 0/1
- kleine, schnelle Programme
- sehr fehleranfällig
- an den Prozessortyp gebunden
Assemblercode:
- etwas anschaulicher (mnemonische Symbole)
- geringer Speicherbedarf
- schnelle Ausführungszeit
- auf die jeweilige Hardware zugeschnitten
- Übersetzt wird mittels Assemblers in die Maschinensprache
- Kosten eines Programmierers überwiegen
Hochsprachen:
- Befehle ähneln der Umgangssprache
- leicht zu warten
- mit weniger (Kosten)-Aufwand erweitern/verbessern
- geht vom zum lösenden Problem aus

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
3. Generation: prozedurale, problemorientierte Hochsprache (Problem im Mittelpunkt)
4. Generation: nonprozedurale Hochsprache (was das Programm leisten soll)
5. Generation: Künstliche Intelligenz
Objektorientierte Generation: Problemlösung mit verschiedenen Objekten (mit Eigenschaften und Methoden)

prozedural: Folge von Anweisungen
strukturiert: Trennung von Daten und Prozeduren

strukturierte Programmierung:
+ erfolgreichen Lösungsansatz bei komplexeren Aufgabenstellungen
- Trennung zw. Daten und Prozeduren bei zunehmender Datenmenge schwierig
- Widerverwendbarkeit zu gering

Virtueller Universalrechner,
besteht aus 5 Funktionseinheiten:
-Steuerwerk
-Rechenwerk
-Ein und Ausgabewerk
-Speicher
I
nformationen zw. diesen Einheiten werden über
Daten, Steuer und Adressbus ausgetauscht.

Imperative Programmiersprachen basieren auf Befehlen
- Anpassung durch aufeinander folgende Befehle
sinnvolle Reihenfolge -> funktioniert auf VNR -> funktioniert überall

funktionale Programmierung:
Lösen der Probleme durch berechnen von Funktionen.

logische Programmierung:
Fakten und Regeln;
Antwort mit richtig oder falsch

deklarativ: aussagenorientiert
imperativ: befehlsorientiert

Kapselung:
Alle Eigenschaften und Methoden in der Definition des Objekts.

Verbergen von Daten:
Nicht nötig Funktionsweise zu kennen – nur Anwendung ist wichtig.

Vererbung:
Objekt baut auf Eigenschaften eines anderen Objekts auf.

Polymorphie:
Objekte verwenden dieselbe Methode und unternehmen die richtigen Schritte, um die Funktion auszuführen.
Sie interpretieren die Nachricht, abhängig von der Verwendung, unterschiedlich.

Wiederverwendbarkeit:
- spart Zeit und Geld
- Stabilität
- Verbesserung / Weiterentwicklung

Klasse: Bauplan (Definition eines Würfels)

Objekt: Komponenten (Würfel, rotes Männchen)

Eigenschaften: Attribute (Farbe, Größe)

Methode: Funktionen (würfle, ziehe)

Programme können nach Bedarf aus einzelnen Objekten zusammengestellt werden.
Die Komponenten müssen so nicht immer neu erfunden werden.

Assembler:
- maschinennah
- mnemotechnisch
- wird in Maschinensprache assembliert

Compiler:
- am Stück übersetzt
- bezogen auf ein OS
- selbstständig lauffähig

Interpreter:
- zur Laufzeit übersetzt (Schritt für Schritt)
- Shell- oder Wirtprogramm wird benötigt zur Ausführung

Compiler:
- C
- C++
- COBOL
- Smaltalk
- Pacal

Interpreter:
- VBA
- Perl
- PHP
- JavaScript

Java wird mit dem Compiler in Bytecode übersetzt.
Benötigt wird dann eine Java Virtual Machine(JVM) zur Ausführung, welche es für verschiedene Plattformen gibt.

Alle Microsoft.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.
=> beliebige MSIL-Code Module unterschiedlicher .NET Programmiersprachen können kombiniert werden

Ein Algorithmus ist eine Reihenfolge von Anweisungen zur Lösung eines Problems.

Abstraktion: eine Art Unterprogramm in einem Algorithmus. Wird mit dem Namen aufgerufen und führt dann eine ganze Reiche von Anweisungen aus.

Abstraktion: eine Art Unterprogramm in einem Algorithmus. Wird mit dem Namen aufgerufen und führt dann eine ganze Reiche von Anweisungen aus.

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

Softwaretechnik: Entwurf und Entwicklung von Software-Systemen einschließlich Dokumentation und widerverwendbaren Komponenten.

Programmbibliothek:
* widerverwendbare Softwarekomponenten abgelegt
* zu teuer das Rad jedes Mal neu zu erfinden

Top-Level-Entwurf:
* allgemeine Problemlösung
* Komponenten, aus denen sich das Programm zusammensetzt, werden aufgeschlüsselt (Teambildung)

Software-Technik im Kleinen:
* Jede Komponente durchläuft die 3 Phasen:
Entwurf,
Implementierung (Programm schreiben)
und Test
* Zusammenfügung der Komponenten nach dem erfolgreichen Komponententest

Systemintegration / Systemtest:
* getesteten Einzelkomponenten des Softwaresystems werden zusammengefügt
* Prüfung ob die einzelnen Komponenten zusammen funktionieren

Fehler bei Systemintegration / Systemtest:
* zwei Datenbanken, die als einzelne funktionieren müssen nicht unbedingt zusammen funktionieren (z.B. beim Laden von Daten, Speichern, etc.)

korrekter Entwurf:
* spart Zeit und Entwicklungskosten
* Änderungen am Entwurf einfacher als nach den Tests

Struktogramme:
* umständlich Vorgehensweisen (Algorithmen) vollständig schriftlich festzuhalten
* kein „goto“
* zusätzlich Dokumentation

Bedarf Struktogramm:
* nach Größe des Projekts
* Aufgabenstellung

kopfgesteuerte Schleife:
Abfrage vor der Durchführung der Verarbeitung Bedingung bei der ersten Abfrage nicht erfüllt => keine Verarbeitung (while) fußgesteuerte Schleife: Abfrage nach dem Durchlauf der Verarbeitung (läuft also min. einmal durch / repeat)

Kompilieren:
* Compiler liest Quelltextdateien (.cpp; .h) und erzeugt einen Zwischencode (.obj; .lib)

Linken:
* Linker verbindet diese Komponenten und erstellt *.exe.

Aufbau C++ Projekt:
* hierarchische Struktur (wie Explorer)
* oberster Knoten ist die Solution (Projektmappe)
* untergeordnet sind mehrere Projektknoten
* mehrere Projekte können innerhalb einer Projektmappe verwaltet werden

Vorteile von Quelldateien in einem Projekt:
* alle in einem Projekt werden in der richtigen Reihenfolge kompiliert und gelinkt

=> einfacher für Compiler/Linker, da nur eine „main“

include: Suche die Datei in den spitzen Klammern und setzte sie genau an der Stelle im Programm ein.

main:
* genau nur eine Hauptfunktion
* das eigentliche Programm (zwischen {})
* wird beim Programmstart automatisch aufgerufen

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

Zweck Kommentare:
* zur eigenen (bzw. für andere) Orientierung/Verständnis
* Notizen

Deklaration von Variablen und Konstanten:
Speicherplatz wird reserviert
"double radius" Name = radius,
Typ = double

Initialisierung von Variablen und Konstanten:
Wert wird zugewiesen
"radius = 20" = Zuweisungsoperator

Deklaration + Initialisierung = Definition

Elementare Typen in C++:
short 2 Byte
int 4 Byte
long 4 Byte
float 4 Byte
double 8 Byte
char 1 Byte

literale Konstante:
* Eintippen an der Stelle des Vorkommens
* nicht mehr veränderbar

symbolische Konstante:
* hat einen Namen (PI)
* nicht mehr veränderbar
* wird mit Namen aufgerufen (nicht 3,14159)

Deklaration von Funktionen:
* Funktionskopf (Prototyp)
* in Headerdatei
Rückgabetyp Bezeichner (Parametertyp Parameter);
double Quadrat (double seite);

Definition von Funktionen:
* Funktionsrumpf
* in Quelltextdatei

double Quadrat (double seite)
{ return seite * seite ; }

Funktionsaufruf in C++:
* im Hauptprogramm
* mit Name und Übergabeparameter
Addiere (4, 35)
* 4 und 35 werden an die Funktion Addiere übergeben
* springt in den Funktionsrumpf
- nach der Abarbeitung wieder zurück

Gebrauch von Funktionsprototyp:
* vor dem ersten Gebrauch
* normal Headerdatei

Gebrauch von Funktionsdefinition:
* egal – nur nicht in eine andere Definition

kopfgesteuerte Schleife:
Abfrage vor der Durchführung der Verarbeitung Bedingung bei der ersten Abfrage nicht erfüllt => keine Verarbeitung (while)

fußgesteuerte Schleife:
Abfrage nach dem Durchlauf der Verarbeitung (läuft also min. einmal durch / repeat)