Nicht markiert

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.

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.