Programmiersprachen im Allgemeinen

Aus Spieleprogrammierer-Wiki
(Unterschied zwischen Versionen)
Wechseln zu: Navigation, Suche
[unmarkierte Version][unmarkierte Version]
(→Die Stärken)
(→Die Schwächen)
 
(36 dazwischenliegende Versionen von 5 Benutzern werden nicht angezeigt)
Zeile 16: Zeile 16:
 
== C++ ==
 
== C++ ==
 
===== Der Einsatzbereich =====
 
===== Der Einsatzbereich =====
−
Neben C und C# die meist genutzte Programmiersprache.<br />
+
Ä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 =====
 
===== Die Stärken =====
−
Die Stärken von C++ liegen<br />
+
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.<br />
 +
 
 +
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 =====
 
===== Die Schwächen =====
−
Die Schwächen von C++ sind<br />
+
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.<br />
−
===== Die Syntax =====
+
 
−
<sourcecode lang=csharp>
+
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 =====
 +
<sourcecode lang=cpp>
 +
// 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 <iostream>
−
/*Das ist ein mehrzeiliger
+
#include <vector> //Headerdateien verschiedener eingebauter Standardbibliotheken einbinden
−
Kommentar.*/
+
  
−
int main()
+
// 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.
 
{
 
{
−
     //Hallo Welt! ausgeben
+
     T X, Y; //unsere zwei x- und y-Komponenten vom Datentyp 'T'.
−
     std::cout << "Hallo Welt!" << std::endl;
+
     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;
+
     return 0; //Diese Funktion verlassen und dem Aufrufer 0 zurückgeben. Heißt hier: Programm beenden!
 
}
 
}
 
</sourcecode>
 
</sourcecode>
Zeile 38: Zeile 105:
 
== C# ==
 
== C# ==
 
===== Der Einsatzbereich =====
 
===== Der Einsatzbereich =====
−
Neben C und C++ die meist genutzte Programmiersprache. Die Sprache ist objektorientiert und typsicher.<br />
+
Neben C, C++ und Java die meist genutzte Programmiersprache. Die Sprache ist objektorientiert und typsicher.<br />
  
 
===== Die Stärken =====
 
===== Die Stärken =====
−
Die Stärken von C# liegen in der vergleichsweise einfachen Struktur der Syntax. Ebenso ist die Fehleranfälligkeit geringer, als bei C++.<br />
+
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.<br />
−
C# liefert mit .Net hilfreiche Tools zur Entwicklung, wie z.B. WPF und WinForms. Für den schnellen Einstieg sind weniger Konfigurationen nötig.<br />
+
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.<br />
  
 
===== Die Schwächen =====
 
===== Die Schwächen =====
−
Die Schwächen von C# sind<br />
+
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.<br />
 +
Weiterhin ist das Programmieren auf Windows und dessen Ableger beschränkt, kann jedoch auch bis zu einem Gewissen Grad dank [https://de.wikipedia.org/wiki/Mono_(Software) 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, [https://de.wikipedia.org/wiki/Mutex 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.<br />
 +
 
 
===== Die Syntax =====
 
===== Die Syntax =====
 
<sourcecode lang=csharp>
 
<sourcecode lang=csharp>
Zeile 75: Zeile 148:
 
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.<br />
 
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.<br />
 
===== Die Stärken =====
 
===== Die Stärken =====
−
Kann sowohl für die Client seitige sowie die Server seitige Programmierung benutzt werden.
+
Kann sowohl für die Clientseitige sowie die Serverseitige Programmierung benutzt werden.
−
Durch das Superset TypeScript ist es nun einfacher objektorientiert zu programmieren.<br />
+
Durch das Superset 'TypeScript' ist es nun einfacher möglich objektorientiert zu programmieren.<br />
  
 
===== Die Schwächen =====
 
===== Die Schwächen =====
Zeile 117: Zeile 190:
 
== Pascal ==
 
== Pascal ==
 
===== Der Einsatzbereich =====
 
===== 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 (dll's, etc.) gegeben ist.<br />
+
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.<br />
 +
 
 
===== Die Stärken =====
 
===== 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).<br />
 
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).<br />
 +
FreePascal ist für eine vielzahl an Plattformen verfügbar (http://wiki.freepascal.org/Platform_list).<br />
 +
 
===== Die Schwächen =====
 
===== Die Schwächen =====
−
Die Schwächen von Pascal sind... <br />
+
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.<br />
−
===== Die Syntax =====
+
 
 +
===== Lizenzen =====
 +
 
 +
<u>FreePascal-Compiler:</u><br />
 +
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/)
 +
 
 +
<u>Lazarus:</u><br />
 +
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 =====
 
<sourcecode lang=pascal>
 
<sourcecode lang=pascal>
 +
program BSP_Car;
 
{
 
{
−
   Mehrzeiliger Kommentar.
+
   This program demonstrate the language PASCAL (object pascal) in the
 +
  FreePascal-dialect.
 
}
 
}
−
program HalloWorld;
+
uses crt; // including the unit crt
−
uses 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
 
begin
−
   WriteLn("Hello World!");
+
   inherited create;               // this is optional.
−
   readkey;
+
   power          := _power;
−
end.
+
  gas_consumption := _gas_consumotion;
 +
end; {create}
  
−
// Ausgabe: Hello World!
+
 
 +
 
 +
// 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.
 +
                     
 
</sourcecode>
 
</sourcecode>
−
...
 

Aktuelle Version vom 3. Juli 2017, 21:53 Uhr

Klicke hier, um diese Version anzusehen.

Von „https://www.spieleprogrammierer.de/wiki/Programmiersprachen_im_Allgemeinen“
Meine Werkzeuge
Namensräume
Varianten
Aktionen
Navigation
Werkzeuge