Programmiersprachen im Allgemeinen
Bitte beachte, dass dieser Artikel noch unvollständig ist! Hilf mit, ihn fertigzustellen.
Näheres dazu findest du ggf. auf der Diskussionsseite. Wenn du der Meinung bist, dass der Artikel vollständig ist, kannst du diesen Hinweis entfernen.
Unter den vielen Programmiersprachen erfreuen sich manche sehr großer Beliebtheit. Dabei haben alle Sprachen ihren eigenen Einsatzbereich. Manche decken dabei große Felder ab, andere Sprachen sind spezialisierter. Jede Sprache zeichnet sich durch besondere Stärken aus, kann aber auch Schwächen gegenüber anderen Sprachen aufweisen.
Im Folgenden werden die meist genutzten Sprachen aufgelistet und kurz erläutert.
Inhaltsverzeichnis |
C
Der Einsatzbereich
Die weltweit am meisten genutzte Programmiersprache. Sie diente ursprünglich der Systementwicklung, wird heute aber auch in anderen Bereichen genutzt.
Die Stärken
Die Stärken von C liegen
Die Schwächen
Die Schwächen von C sind
Die Syntax
...
C++
Der Einsatzbereich
Ähnlich wie C findet sie große Verwendung bei der Entwicklung von eingebetteten Systemen und Betriebssystemen. Auch in der Entwicklung von Spielen und allgemeinen Anwendungen ist sie stark vertreten und kann somit zum de-facto-Standard gezählt werden.
Die Stärken
C++ vereint Effizienz und effektives Programmieren. Dem Programmierer wird im Gegensatz zu C einiges abgenommen, dennoch besteht weiterhin stets ein guter Überblick über das, was "hinter den Kullissen" passiert. Dank mächtiger Konstrukte wie den Templates sowie RAII werden doppeltes Schreiben vereinfacht und Fehlerquellen vermieden.
Aufgrund der anfänglichen Verwandtheit zu C stehen dem C++-Programmierer nicht nur eine Vielzahl von in C++ geschriebenen Erweiterungsbibliotheken, beispielsweise zur Netzwerkkommunikation oder zum Erstellen von graphischen Benutzeroberflächen zur Verfügung, sondern auch nahezu sämtliche in C programmierte.
Die Schwächen
Aufgrund der Entstehung aus C sind einige Konstrukte in C++, wie beispielsweise Arrays, wenig intuitiv zu bedienen. Ein weiteres Problem besteht in der Weise, wie C++-Code übersetzt und ein lauffähiges Programm gebaut wird. Externe Bibliotheken müssen nicht selten eigens zu binären Moduldateien kompiliert werden, da diese nicht standardisiert sind und somit von Compiler zu Compiler unterschiedlich sind. Selbst unterschiedliche Versionen eines Compilers können Konflikte bereiten.
Tatsächliche existieren diverse Irrtümer über C++, sowohl in Büchern als auch im Internet, wie beispielsweise:
- in C++ muss man selbst Memorymanagement betreiben
- Zeiger sind Fehleranfällig oder
- es kommt in C++-Programmen oft zu Pufferüberläufen und Memoryleaks
Dies ist häufig der Tatsache geschuldet, dass C und C++ in einen Topf geworfen wird, sodass am Ende die "Programmiersprache" C/C++ dabei herauskommt. Besonders in Lehrvideos ist "C/C++" populär geworden, weshalb stets zu einem guten Buch geraten wird. C und C++ sind verschiedene Sprachen und besonders durch ihre letzten wichtigen ISO-Standards C++11 sowie C11 enorm auseinandergedriftet. Deshalb ist es überaus wichtig beim Lernen von modernem C++ diese Programmiersprache nicht wie ein erweitertes C zu behandeln. Beide unterliegen verschiedenen Designgedanken.
Eine weitere Schwäche ist die Mehrfachvererbung von C++, die selbst erfahrenen Programmierern Probleme bereitet (Programmiersprachen wie Java und C# verzichten komplett auf die Möglichkeit der Mehrfachvererbung. Diese Sprachen haben die um einiges einfache Interface Variante implementiert). Meistens wird diese Schwäche umgangen, in dem Mehrfachvererbung nicht verwendet wird.
Ein Beispielprogramm
// Das hier ist ein einzeiliger Kommentar. Diese Zeile wird vom Kompiler ignoriert und dient // beispielsweise der Dokumentation des Quellcodes. /* mehrzeilige Kommentare funktionieren auch */ #include <iostream> #include <vector> //Headerdateien verschiedener eingebauter Standardbibliotheken einbinden // Zuerst bauen wir uns eine Klasse, welche einen 2-dimensionalen Vektor repräsentiert. // Ihre Komponenten können verschiedenen Typs sein, beispielweise eine Fließkommazahl float, eine ganze Zahl int // oder jeder andere Datentyp, der arithmetische Operatoren anbietet. So auch eigens definierte. template<class T> //template signalisiert, dass 'Vector2D' ein 'Template' ist. T stellt hierbei einen beliebigen Datentypen dar. struct Vector2D //die Schlüsselwörte 'struct' und 'class' bedeuten nahezu dasselbe. { T X, Y; //unsere zwei x- und y-Komponenten vom Datentyp 'T'. Vector2D(T x, T y) : X(x), Y(y) {} //Wird eine Instanz dieses Vektors erstellt, kann dieser sofort deren Komponenten initialisiert werden. Vector2D() : X(T()), Y(T()) {} //...wenn nicht, werden beide auf den Standardwert des Typs 'T' gesetzt // Damit wir Vektoren auch addieren können, wird hier der +-Operator für unsere Klasse definiert. // Analog funktioniert das auch mit anderen Operatoren. // Diese Methode nimmt eine Referenz auf eine andere Vektorinstanz (d.h. der rechte Operand bei Plus) // und gibt eine neue Vektorinstanz zurück. Beide Operanden dürfen in dieser Methode nicht verändert werden und // sind deshalb als 'const' markiert. Vector2D operator+(const Vector2D &v) const { return {X + v.X, Y + v.Y}; //beides addieren und dem Aufrufer des Operators eine neue Vektorinstanz zurückgeben. } }; // Dieser Operator gibt beliebige Vektorinstanzen auf dem angegebenen Outstream aus. // Durch die Überladung des Operators wird die Ausgabe des Vektors als Text in der Konsole vereinfacht. template<class T> static std::ostream &operator<<(std::ostream &output, const Vector2D<T> &v) { // Beide Komponenten ausgeben, indem auf die X-Komponente der Vektorinstanzen zugegriffen wird. // cout, welches im 'Namensraum' std liegt, ist ein Objekt, durch dessen Operator '<<' auf die Ausgabe geschrieben werden kann. output << "(" << v.X << "/" << v.Y << ")\n"; //...danach noch eine neue Zeile (\n) ausgeben return output; } int main() //diese Funktion ist der Einstiegspunkt des Programms { // Zwei Vektoren mit den Namen 'v1' und 'v2' erstellen. Vector2D<float> v1(1.4f, 2.1f); //Instantiiert einen Vector2D, dessen Komponenten eine Fließkommazahl und auf 1.4 und 2.1 gesetzt sind. Vector2D<int> v2; //Es werden keine Konstruktionswerte angegeben, d.h. x und y werden auf 0 gesetzt. // im v2 sind nur Ganzezahlen als Argumente gültig std::cout << v1 << v2; //Beide Vektoren ausgeben. std::vector<Vector2D<float>> list; //eine Liste (=Vektor) von Vektor2f-Instanzen, die beliebig wachsen kann. Zuerst ist sie leer. Vector2D<float> temporary; // liest eine leerzeichengetrennte Folge von x- und y-Komponenten ein, bis // der Benutzer abbricht (z.B durch Strg+Z) oder das Eingegebene keine Zahl ist. while(std::cin >> temporary.X >> temporary.Y) { list.push_back(temporary); //fügt den neuen Vektor2f der Liste hinzu. } for(const auto &v : list) //Alle Elemente der Liste durchgehen und ausgeben. v wird nacheinander alle Elemente referenzieren. std::cout << v + v1; //...addiert vorher den Vektor 'v1' dazu. return 0; //Diese Funktion verlassen und dem Aufrufer 0 zurückgeben. Heißt hier: Programm beenden! }
C#
Der Einsatzbereich
Neben C, C++ und Java die meist genutzte Programmiersprache. Die Sprache ist objektorientiert und typsicher.
Die Stärken
Die Stärken von C# liegen in der Einfachheit, komplexe Aufgaben lösen zu können. Dank des großen Umfangs des verwendeten .Net-Frameworks werden zahlreiche Funktionalitäten bereitgestellt. Für den schnellen Einstieg sind weniger Konfigurationen nötig.
C# Programme werden durch den Compiler in keinen Maschinencode übersetzt, sondern in eine Zwischensprache (Common Intermediate Language oder auch CIL genannt). Dies bietet den Vorteil, dass Projekte mit verschiedenen anderen Programmiersprache der .Net-Familie programmiert werden können. Weiterhin lassen sich so direkt Programme sowohl auf Windows als auch auf Windows Phone und weiteren Geräten verwenden.
Für den Programmierer ist die Garbage Collection (automatische Speicherfreigabe) ein weiterer Vorteil. Der Speicher nicht mehr verwendeter Objekte braucht nicht explizit freigegeben werden, wie es beispielweise bei C der Fall ist.
Die Schwächen
Eine Schwäche die C# im Gegensatz zu C und C++ hat, ist die Verarbeitungsgeschwindigkeit. Durch die Verwendung einer Zwischensprache, muss ein C# Programm während der Laufzeit in Maschinencode übersetzt werden. Dieser Nachteil ist für den Benutzer jedoch meist nicht spürbar.
Weiterhin ist das Programmieren auf Windows und dessen Ableger beschränkt, kann jedoch auch bis zu einem Gewissen Grad dank Mono auf anderen Plattformen und Betriebssystem funktionieren.
Die automatische Speicherfreigabe kann jedoch auch als Schwäche betrachtet werden, da der Garbage Collector hierbei lediglich den von nicht mehr verwendeten Objekten belegten Speicher freigibt. Bei anderen Ressourcen, wie geöffnete Dateien, Texturen, Netzwerkverbindungen, Mutexe und weiteren muss deshalb selbst Hand andgelegt und diese geschlossen werden. So kann es durchaus zu Bugs und instabilen Programmen führen, weil genannte Ressourcen nicht ordnungsgemäß freigegeben werden. Durch Anwenden der sogenannten using-Blöcke lässt sich dies jedoch eindämmen.
Die Syntax
using System; public class Program { public static void Main() { Console.WriteLine("Hello World!"); } } // Ausgabe: Hello World!
Java
Der Einsatzbereich
Java ist neben den C-Sprachen die zweithäufigste Programmiersprache. Durch den eigenständigen Interpreter Java Virtual Machine ist Java plattformunabhängig.
Die Stärken
Die Stärken von Java liegen
Die Schwächen
Die Schwächen von Java sind
Die Syntax
...
JavaScript
Der Einsatzbereich
JavaScript ist neben PHP die meistgenutzte Sprache für die Webentwicklung. JavaScript wird im Browser des Users ausgeführt und dient dem Versenden von Daten oder der Manipulation der Webseite. Die Sprache steht in keiner Verbindung zu Java, sondern ist eine eigenständige Scriptsprache.
Die Stärken
Kann sowohl für die Clientseitige sowie die Serverseitige Programmierung benutzt werden.
Durch das Superset 'TypeScript' ist es nun einfacher möglich objektorientiert zu programmieren.
Die Schwächen
Die Schwächen von JavaScript sind
Die Syntax
//Die script Tags werden benutzt um den JS Code in eine HTML Seite einzubetten. <script>console.log('Hallo Welt')</script>
PHP
Der Einsatzbereich
PHP ist neben JavaScript die meistgenutzte Sprache für die Webentwicklung. PHP dient primär der Entwicklung von Webseiten und serverbasierten Webanwendungen.
Die Stärken
Die Stärken von PHP liegen
Die Schwächen
Die Schwächen von PHP sind
Die Syntax
<?php /*Das ist ein mehrzeiliger Kommentar.*/ //Hallo Welt! ausgeben echo "Hallo Welt!"; ?>
Python
Der Einsatzbereich
Python ist der Allrounder der Programmiersprachen. Die Sprache ist auf keinen bestimmten Anwendungsbereich spezialisiert und zeichnet sich durch eine klare und simple Syntax aus. Python kann objektorientiert, aspektorientiert oder funktional genutzt werden. Sie kann zudem auch als Skriptsprache dienen.
Die Stärken
Die Stärken von Python liegen
Die Schwächen
Die Schwächen von Python sind
Die Syntax
...
Pascal
Der Einsatzbereich
Pascal ist eine Sprache, die mehr ein Nischendasein fristet. Sie wird heute nur noch selten verwendet. Wird aber im Rahmen des FreePascal-Projekts von der Community und ein paar Unternehmen stets weiter entwickelt und an modernen Programmierkonzepten angepasst, so das auch heute noch der Anschluss an modernen Bibliotheken (DLLs, etc.) gegeben ist.
Die Stärken
Die Stärken von Pascal liegen in der verständlichen Schreibweise, da Schlüsselwörter voll ausgeschrieben werden. Ein, gegenüber C, einfaches Arbeiten mit Zeichenketten viel Open-Source und, trotz des Nischendaseins, umfassende Dokumentationen und einer freundlichen, hilfsbereiten Commiunity (auch auf Deutsch: http://www.lazarusforum.de). Mit Lazarus bietet FreePascal eine komfortable, kostenlose Entwicklungsumgebung, die sich nach belieben anpassen lässt. (http://www.lazarus-ide.org).
FreePascal ist für eine vielzahl an Plattformen verfügbar (http://wiki.freepascal.org/Platform_list).
Die Schwächen
Auch wenn Pascal mit modernen Bibliotheken zurecht kommt ist hier doch oft eigenarbeit gefragt, die Bibliotheken mit Pascal zu verbinden oder eine neuere Version einer Bibliotek kompatibel zu machen. Hier zeigt sich das Nieschendasein, das Potenzial ist da muss aber teilweise mühsam verfügbar gemacht werden, was für ein erfahrenen Programmierer jedoch kein Problem dar stellen sollte.
Lizenzen
FreePascal-Compiler:
The packages and runtime library come under a modified Library GNU Public License to allow the use of static libraries when creating applications. The compiler source itself comes under the GNU General Public License. The sources for both the compiler and runtime library are available; the complete compiler is written in Pascal. (https://www.freepascal.org/)
Lazarus:
LGPL licensed libraries allow you to create your own applications under any license you desire. Even commercial closed source. (https://www.lazarus-ide.org/index.php?page=features)
Ein Beispielprogramm
program BSP_Car; { This program demonstrate the language PASCAL (object pascal) in the FreePascal-dialect. } uses crt; // including the unit crt type tcMotor = class private power : Real; gas_consumption : Real; public constructor create(_power, _gas_consumotion : Real); function gas(gas_level : Real) : Real; property get_Power : Real read power; property get_gas_consumption : Real read gas_consumption; end; {tcMotor} type tcCar = class private Motor : tcMotor; weight : Real; tank_volume : Integer; tank_current : Real; speed : Real; public constructor create(TheMotor : tcMotor; _weight : Real; _tank_volume : Integer); destructor destroy; procedure accelerate(gas_level : Real); procedure brake; // you can also write with brackets -> brake(); function fuel : Real; // you can also write with brackets -> fuel() : Real; property get_Motor : tcMotor read Motor; property get_weight : Real read weight; property get_tank_volume : Integer read tank_volume; property get_tank_current : Real read tank_current; property get_speed : Real read speed; end; {tcCar} //----------------------------------------------------------------------------- // class tcMotor //----------------------------------------------------------------------------- // create a motor. constructor tcMotor.create(_power, _gas_consumotion : Real); begin inherited create; // this is optional. power := _power; gas_consumption := _gas_consumotion; end; {create} // gas the motor. function tcMotor.gas(gas_level : Real) : Real; begin if gas_level > 1 then gas_level := 1; if gas_level < 0 then gas_level := 0; result := power * gas_level; end; {gas} //----------------------------------------------------------------------------- // class tcCar //----------------------------------------------------------------------------- // Create a car. constructor tcCar.create(TheMotor : tcMotor; _weight : Real; _tank_volume : Integer); begin inherited create; // this is optional. Motor := TheMotor; weight := _weight; tank_volume := _tank_volume; tank_current := Real(tank_volume); speed := 0; end; {create} // Scrap the car. destructor tcCar.destroy; begin Motor.destroy; inherited destroy; end; {destroy} // accelerate the car. procedure tcCar.accelerate(gas_level : Real); begin if Motor <> nil then begin if gas_level > 1 then gas_level := 1; if gas_level < 0 then gas_level := 0; Speed := Motor.gas(gas_level) / (Weight + tank_current/1000); tank_current := tank_current - Motor.get_gas_consumption * gas_level; end; end; {accelerate} // brake the car. procedure tcCar.brake; // you can also write with brackets -> brake(); begin if Motor <> nil then Motor.gas(0); speed := 0; end; {brake} // Refuel the tank and return the amount of the fueld gas. function tcCar.fuel : Real; // you can also write with brackets -> fuel() : Real; begin result := Real(tank_volume) - tank_current; tank_current := Real(tank_volume); end; {fuel} //----------------------------------------------------------------------------- // functions and procedures //----------------------------------------------------------------------------- procedure printCarStats(Car : tcCar); begin Writeln('---------------------------------------------------------------'); Writeln('Speed: ', Car.get_speed:0:2); Writeln('tank-level: ', Car.get_tank_current:0:2); Writeln('---------------------------------------------------------------'); Writeln; end; {printCarStats} //----------------------------------------------------------------------------- // Main //----------------------------------------------------------------------------- var Car : tcCar; begin Writeln('Create the Car.'); Car := tcCar.Create(tcMotor.create(30, 0.5), 1.5, 60); printCarStats(Car); Writeln('Accelerate the Car.'); Car.accelerate(1); printCarStats(Car); Writeln('Brake the Car.'); Car.brake(); printCarStats(Car); Car.destroy; Readkey(); end.