Workshop von Zerd und XBelt geschlossen

[Zerd]

Hallo zusammen, ich nutze diesen ersten Teil des Workshops um zu sehen wie groß das Interesse ist. Also alle die den Workshop bis zuende gelesen haben mögen dies bitte hier drunter posten

Inhalt des Wokshops

1. 1. Teil
   • Was brauche ich?
     • Visual C++ 2005 Express
     • Platform SDK
   • Beispielprogramm
2. 2. Teil
   • Das erste Programm
     • Bildschirmausgabe mit cout
     • Was macht das std:: vor dem cout?
     • Wie funktioniert cout?
     • Wie starte ich mein Programm?
3. 3. Teil
   • Standard Datentypen
     • Standard Datentypen nach dem C99er Standard
     • Definition von Variablen
     • Tastatureingabe mit cin
     • Übungsaufgabe
4. Teil 4
   • Strings in C++
   • Strukturierte Programmierung
   • Kommentare
5. Teil 5
   • Kontrollstrukturen
     • If Abfrage
     • Aufgabe
     • Switch-Case Anweisung
     • Aufgabe
6. Teil 6
   • Schleifen
     • while-Schleife
     • do-while-Schleife
     • for-Schleife
7. Teil 7
   • Funktionen
     • Beispiel
     • Erklärung
     • Übung
   • Rekursion
     • Beispiel
     • Übung
8. Teil 8
   • Call By Value
   • Zeiger
     • Was sind Zeiger?
     • Wie benutze ich Zeiger?
   • Zeigervariablen übergeben
9. Teil 9
   • Der Präprozessor
   • Bedingte Kompilierung
   • Makros

Was brauche ich?
Visual C++ 2005 Express
Ich benutze für den Workshop die IDE "Microsoft Visual C++ 2005 Express" welche es freundlicherweise bei Microsoft kostenlos zum download gibt. Für die meisten Anwendungen gerade am Anfang reicht diese Version. Um trotzdem auf die Nachteile zu den Kostenpflichtigen Versionen einzugehen unterstützt die Express Version beispielsweise keine MFC anwendungen (Vermutlich geht das den Programmieranfängern schon ein stück zu weit, aber ist nicht schlimm, ignoriert es einfach ).

Hier gibt es die Kostenlose Version der Visual C++ 2005 IDE
http/http/msdn.microsoft.com/vstudio/express/downloads/default.aspx
(VisualStudio 2005 Express Edition auswählen)

Platform SDK
Neben der IDE benötigen wir noch das Platform SDK. Dieses SDK beinhaltet diverse bibliotheken die nicht mit der Express version ausgeliefert werden.
Download details: Windows® Server 2003 R2 Platform SDK Full Download
Bei problemen mit dem Download könnt ihr auch die ISO runterladen: Download details: Windows® Server 2003 R2 Platform SDK ISO Download

Die Downloads werden denke ich einige Zeit brauchen, also heißt es jetzt erstmal abwarten...
...
Nachdem die Downloads abgeschlossen sind könnt ihr schonmal Visual C++ installieren. (Ich erinner mich grade nich ob es bei der installation was zu beachten gab, wenn ja meldet euch, dann werde ich es nochmal nachsehen und ergänzen). Ach ja.. eine Sache gabs da noch Soweit ich mich richtig erinner muss man das Visual Studio bei Microsoft registrieren. Da es aber kostenlos ist kann man das ruhig machen.

Okay, weiter im Programm. Die Installation ist abgeschlossen und nun kommt das Platform SDK. Installiert es und merkt euch den Pfad wohin ihr es installiert habt.

Startet das Visual Studio und navigiert zu den Optionen:

Klickt jetzt auf "Projekte und Projektmappen" und dann auf "VC++ Verzeichnisse"

Dort seht ihr jetzt eine Liste in denen einige Pfade angezeigt werden. Über der Liste gibt es 2 Combo boxen. Die erste ("Plattform"), ist nicht relevant. Die zweite brauchen wir um durch die verschiedenen Verzeichnislisten zu navigieren. In der ersten Liste (Ausführbare Dateien) legt ihr eine neue Zeile an in der ihr dann das Bin verzeichnis der Plattform SDK angebt (z.B.: "C:\programme\plattform SDK 2003...\Bin"

Dementsprechend navigiert ihr oben in der Verzeichnisliste zu "Includedateien" und fügt eine neue Zeile ein: "C:\programme\plattform SDK 2003...\Include"

Und zu guter letzt das selbe nochmal für "Bibliothelsdateien":
"C:\programme\plattform SDK 2003...\Lib"

Das war es soweit mit den Einstellungen der IDE. (Wenn ich nichts vergessen habe sollte sie nun für unsere Zwecke einsatzbereit sein)

Beispielprogramm
Damit ihr nicht völlig unbefriedigt zurück gelassen werden schreiben wir nun noch ein kurzen Programm damit ihr seht wie ihr die IDE benutzt.

Navigiert "Datei->Neu->Projekt". In dem Dialog wählt ihr Win32 und Win32-Konsolenanwendung. Gebt dem Projekt noch einen Namen und klickt auf OK.

Als nächstes Klickt ihr auf Weiter und wählt im nächsten Dialog "Leeres Projekt"

-> Fertig Stellen

Jetzt seht ihr am linken Bildschirmrand den Projektmappen explorer. Um nun eine neue Datei hinzu zufügen klickt ihr mit der rechten Maustaste auf "Quelldateien -> Hinzufügen -> Neues Element" und wählt C++-Datei. Gebt ihr wieder einen Namen und drückt auf Hinzufügen.

Als letztes kopiert ihr den Quellcode den ich jetzt hier hinschreibe und versucht ihn zu kompilieren. (Ich gehe hier nicht auf das Programm ein weil das nur zu testzwecken genutzt wird)

#include 

int main() {

std::cout  return 0;
}

Zum kompilieren drückt ihr F7 oder navigiert "Erstellen -> Projektmappe erstellen"



Wie schon erwähnt gilt dieser erste "Workshop" erstens um denen die interesse haben zu erklären was benötigt wird und um zu sehen wie viele wirklich interesse haben. Außerdem sind verbesserungsvorschläge erwünscht . Also wenns gut ist, fehler vorhanden sind, etwas unklar ist oder sonst was, einfach antworten. Wenn genug feedback ist überlege ich ob es sich lohnt den Spaß weiter zu führen

Gruß Zerd

Das erste Programm
Nachdem wir nun die IDE eingerichtet haben wollen wir langsam mit den ersten kleinen Programmen anfangen.

Ich beginne mit dem kleinst-möglichen C++ Programm und ergänze dieses im laufe dieser Lektion. Startet hierzu genau wie ich es in dem Programmbeispiel in der letzten Lektion erklärt habe und erstellt ein neues Projekt.

Das kleinste C++ Programm: (Ich benutze PHP codetags weil der code dann schöner formatiert wird)

void main() {

}

Kleine Anmerkung zu diesem Programm: void main() entspricht nicht dem standard. Daher sollte stattdessen immer int main() mit dem entsprechenden Rückgabewert benutzt werden.

Das Programm macht garnichts. Trotzdem kann man schon etwas lernen. Die funktion die ich gerade dargestellt habe ist die Hauptfunktion eines jeden C++ Programms. Ihr werdet (zumindest am Anfang) immer diese Funktion nutzen um eure Programme zu schreiben.

Damit nun etwas passiert fangen wir einfach mal mit einer einfachen Bildschirmausgabe an.

Bildschirmausgabe mit cout
Schauen wir uns zunächst das folgende Programm an:

#include 
int main() {
std::cout  return 0;
}

Die #include Anweisung ist eine so genannte Präprozessor anweisung. Der Präprozessor verarbeitet den quelltext bevor er dann an den eigentlichen compiler gesendet wird.
Was macht #include jetzt also genau? Mit dieser Anweisung kann man externe Bibliotheken dem aktuellen quelltext "bekannt" machen. In der 3. Zeile des Programmes steht die Zeile "std::cout B] anweisung löscht. Ihr werdet einen Compilerfehler bekommen die besagt das die Anweisung "cout" nicht bekannt ist. Dadurch das die headerdatei "iostream" includiert wird wird dem compiler die anweisung cout bekannt gemacht.

Was macht das std:: vor dem cout?
std gibt an, in welchem namespace die anweisung steht. Ein namespace ist im Prinzip nur eine definition von einem Bereich indem verschiedene Klassen oder Funktionen gespeichert sind. Wenn ihr nicht immer std:: vor die Anweisungen schreiben möchtet könnt ihr direkt über die main() funktion folgendes schreiben: using namespace std;
Habt ihr diese Zeile eingefügt könnt ihr euch die std:: anweisungen for cout und endl sparen.

Wie funktionier cout?
cout ist ein objekt welches funktionen zur Textausgabe in der Konsole zur Verfügung stellt. Durch den Operator

cout code]
Wahrscheinlich ist euch mitlerweile der Begriff [B]endl[/B] aufgefallen. Mit endl wird der Cursor in der Konsole an den Anfang der nächsten Zeile gesetzt. Es entspricht also quasi dem Drücken der Entertaste.

[U][size=3]Wie starte ich mein Programm?[/SIZE][/U]
Nachdem ihr das Programm kompiliert habt (F7 oder über "Erstellen->Projektmappe erstellen") wollt ihr sicher das Programm starten :)
Die exe datei findet ihr im Projektverzeichnis (wo ihr das Projekt gespeichert habt) und dann im Unterordner Debug oder Release. (vermutlich Debug)
Wenn ihr die exe einfach mit Doppelklick startet öffnet sich ein Konsolenfenster, schließt sich aber auch direkt wieder. Nunja, die main() funktion wir aufgerufen und das Programm wird direkt nach der Ausgabe beendet. Um eine Ausgabe zu sehen startet ihr das Programm am besten in der Komandozeile, dazu: Start->Ausführen ... Dann "cmd" und enter eingeben. Jetzt navigiert ihr zu dem Verzeichnis mit der exe datei und startet diese. 

Es gäbe noch diverse Möglichkeiten das Programm daran zu hindern das Fenster zu schließen. Für den Anfang soll das aber erstmal reichen, damit ihr auch noch was zu tun habt ;)

Ich merke grade das ich hunger bekomme, also mache ich hier erstmal schluss :) Zumindest habt ihr jetzt die "Mittel" um etwas auf dem Bildschirm auszugeben. Probiert ruhig etwas damit herum, in der nächsten Lektion fange ich mit Variablen und dem einlesen von Texten an. 

Wie schon erwähnt meldet euch wenn ihr Fehler findet oder Fragen habt.
[URL='http://www.freesoft-board.to/f155/interesse-an-c-c-workshop-205639.html']Hier ist der Diskussionsthread[/URL]

[size=5]Standard Datentypen[/SIZE]
Bevor ich mit den Variablen und dem Einlesen der Tastatur beginnen kann müssen wir zunächst die Standard-Datentypen behandeln damit ihr wisst was ich in dem danach folgenden Beispiel mache.

[U][size=3]Standard Datentypen nach dem C99er Standard[/SIZE][/U]
Integer Datentypen:
[CODE]
char 1 byte Character, Integer-Typ ohne Vorzeichen
signed char 1 byte Character mit Vorzeichen
unsigned char 1 byte Character ohne Vorzeichen, identisch zu char
short 2 byte 2 byte Integer-Typ mit Vorzeichen.
unsigned short 2 byte 2 byte Integer-Typ ohne Vorzeichen.
int 4 byte 4 byte Integer-Typ mit Vorzeichen.
unsigned 4 byte 4 byte Integer-Typ ohne Vorzeichen.
long 8 byte 8 byte Integer-Typ mit Vorzeichen.
unsigned long 8 byte 8 byte Integer-Typ ohne Vorzeichen.
long long 8 byte 8 byte Integer-Typ mit Vorzeichen.
unsigned long long 8 byte 8 byte Integer-Typ ohne Vorzeichen.

Integer Datentypen sind Typen die nur ganzzahlige Werte speichern können. Die größe der Daten die gespeichert werden können hängt vom jeweiligen System ab, daher werde ich da nicht genauer drauf eingehen. unsigned bedeutet dabei das die Variablen nur Positive Werte speichern können. signed definiert dementsprechend einen positiven und einen negativen Wertebereich.

Fließkomma Datentypen:

float 4 byte 4 byte Fließkomma-Typ mit 3 byte Mantisse und 1 byte Exponenten.
double 8 byte 8 byte Fließkomma-Typ mit 53 bit Mantisse und 11 bit Exponenten.
long double 10 byte 10 byte Fließkomma-Typ mit 8 byte Mantisse und 2 byte Exponenten.

Die genauen größen der einzelnen Datentypen sind für den Anfang nicht so wichtig. Wenn ihr sie doch mal brauchen solltet könnt ihr sie hier nachlesen

Definition von Variablen
Hier ein kleines beispiel wie variablen definiert und inizialisiert werden können:

int intVariable = 5;
char charVariable = 'a';
float floatVariable = 1.5f;

Das f bei der zuweisung der float Variable definiert das es sich dabei um eine Gleitkommazahl handelt.

Tastatureingabe mit cin
Schaut euch zuerst einmal den folgenden code an:

#include 

int main() {
int eingabe;
std::cout  std::cin >> eingabe;
std::cout  return 0;
}

In der ersten Zeile definiere ich die Variable eingabe vom Typ char. Das sagt uns schonmal das wir in dieser Variable nur ein Zeichen speichern können.
In der 3. Zeile wird dann cin aufgerufen und mit dem operator >> die Tastatureingabe in der Variable eingabe gespeichert.
Zum schluss gebe ich die Variable mit cout wieder aus.

Bevor ich dieses kleine Kapitel abschließe gebe ich noch eine kleine Übungsaufgabe. Mit dem was ihr bisher gelernt habt solltet ihr in der Lage sein folgende Aufgabe zu lösen:

Übungsaufgabe
Lies 3 Zahlen hintereinander ein, addiere sie und gib die Lösung wieder aus.
Tipp: Das Ergebnis eurer Berechnung kann in einer neuen Variable gespeichert werden. Berechnungen werden dabei in folgender Form gemacht: Wert = wert (+ - * /) wert;

Es ist ein recht kleines und einfaches Programm, wer will kann gerne seine Lösung posten um (falls nötig) Verbesserungsvorschläge zu bekommen. Benutzt dazu bitte wie gehabt Diesen Thread

Strings in C++
Im letzten Kapitel bin ich auf die Standard-Datentypen eingegangen. Natürlich sind das nicht alle Typen die man verwenden kann. Man hat in C++ die möglichkeit vorhandene Klassen zu verwenden oder sich eigene Typen oder Klassen zu definieren.

Ein Beispiel für solch einen Datentyp ist der Typ string. Da wir uns für den C++ Workshop entschieden haben werde ich nicht auf die C variante von strings eingehen.

der Typ string befindet sich genau wie cin und cout in dem namespace std und kann somit wie folgt definiert werden:

std::string name

Damit dieser Typ dem programm bekannt gemacht werden kann muss zusätzlich die header datei string eingefügt werden.

#include

Schauen wir uns ein Beispiel an, indem wir einen String (also eine Zeichenkette) einlesen und in einer Variable speichern:

#include 
#include 

int main() {
std::string nachname;
std::cout  std::cin >> nachname;
std::cout  return 0;
}

Ich denke ihr braucht keine große erklärung für diesen Programmcode. Das einzige was neu ist, ist die Verwendung von std::string.

Bevor ich dieses Kapitel so kurz lasse mache ich noch einen kurzen Exkurs um auf strukturierte Programmierung einzugehen.

Strukturierte Programmierung
Was ich versuchen möchte euch schon von anfang an in diesem Workshop zu vermitteln, ist das ihr euren Quelltext gut und vor allem konsistent formatiert. Schaut euch die folgenden Beispiele an:
Schlechtes Beispiel:

#include 
int main(){
std::string nachname;
std::coutstd::cin>>nachname;
std::coutreturn 0; }

Gutes Beispiel:

#include 

int main() {
std::string nachname;
std::cout  std::cin >> nachname;
std::cout  return 0; 
}

Wenn ihr die beiden (inhaltlich identischen) listings anschaut werdet ihr (hoffentlich) erkennen das der 2. Quellcode um einiges besser lesbar ist. Durch solche (oder ähnliche) Formatierung kann man quellcode leserlich und strukturiert gestalten. Eine gute Strukturierung ist bei großen Projekten unverzichtbar.

Ihr mögt vielleicht jetzt denken: "Ja aber wie machen doch noch keine großen Projekte". Ja das stimmt schon, aber wenn man es direkt ordentlich und richtig lernt muss man es später nicht ändern

Kommentare
Wo ich grade bei Strukturierter Programmierung bin... Da fällt mir auf das ich noch kein bisschen erwähnt habe wie nützlich Kommentare sind
Es gibt 2 Möglichkeiten Kommentare im Quellcode zu hinterlassen:

// Kommentar in einer Spalte

/* Kommentar über mehrere Spalten 
Noch mehr Kommentar
*/

Kommentare sind bei großen Projekten genauso wichtig wie eine gute Struktur. Gerade Funktionen und Klassenvariablen sollten gut kommentiert werden. Dazu kommen wir aber später
Kommentare werden beim Kompilieren des Quellcodes Ignoriert, also macht es nichts aus wenn man viele Kommentare schreibt. Das wirkt sich nicht auf die Größe des Programmes am Ende aus.

Ich werde leider über das Wochenende keine Zeit haben am Workshop weiterzumachen. Montag gehts denke ich dann weiter. Ich würde mich mal über etwas mehr feedback freuen, damit ich weiß das ich den Workshop nicht nur für 2 Leute schreibe
Also wie immer Hier könnt ihr Fragen stellen, verbessern oder einfach nur diskutieren.

Im nächsten Teil wird es dann etwas spannender. Dort werde ich dann auf Kontrollstrukturen und Schleifen eingehen womit dann die Programme endlich etwas sinnvoller werden

Kontrollstrukturen
Kommen wir mal zu etwas nützlichem... (Nicht das ihr jetzt denkt das vorher war sinnlos )
Mit Kontrollstrukturen wie if Abfragen oder switch-case Anweisungen lässt sich der Programmfluss durch angaben von Bedingungen kontrollieren. In diesem Teil werdet ihr lernen wie solche Abfragen funktionieren.
If-Abfrage
Syntax:

if() {
Anweisung1..
Anweisung2..
...
}

Die if-Abfrage ist immer so aufgebaut wie in der Syntax beschrieben. Die Bedingung ist ein eine Logische Abfrage die entweder true (wahr) oder false (falsch) ergibt.

Beispiel:

if(wert==1) {
std::cout }

In diesem beispiel wird der Text "Der Wert war 1" ausgegeben wenn die Variable wert wirklich den Wert 1 beinhaltet. Ist das nicht der Fall wird die Ausgabe einfach übersprungen.

if kann durch eine else anweisung verknüpft werden:

if() {
Anweisungen...
} else {
Alternative Anweisungen...
}

So hat man die möglichkeit alternativ-anweisungen auszuführen falls die Bedingung nicht true ergibt.

Beispiel:

if(wert==1) {
std::cout } else {
std::cout }

Mit dieser Information solltet ihr beispielsweise schon in der Lage sein folgendes Programm zu lösen:
Aufgabe
Schreibt einen Taschenrechner der zunächst 2 Zahlen einliest, danach eine Ausgabe in der Art macht:

Bitte wählen Sie eine Rechenart [+, -, *, /]:

Dort lest ihr nun eines der Zeichen ein und entscheidet mit hilfe der eben gelernten if abfrage welche Berechnung ihr ausführt. Zum schluss gebt ihr das Ergebnis auf dem Bildschirm aus.

Switch-Case Anweisung
Neben der if abfrage gibt es speziell für integer bzw. char werte die Switch-Case Anweisung.
Mit dieser Anweisung kann man eine Variable nach verschiedenen inhalten überprüfen und dem entsprechend eine andere aktion ausführen.

Syntax:

switch(variable) {
case :
Anweisung..
break;
case :
Anweisung...
break;
default:
Anweisung
}

Zur Veranschaulichung hier noch ein kleines Beispiel:

switch(variable) {
case 1:
std::cout  break;
case 2:
std::cout  break;
default:
std::cout }

Diese Anweisung "schaut" also in die Variable und überprüft den Inhalt und entscheidet so in jedem case-block was gemacht wird. der break befehl ist wichtig, da sonst nicht aus dem switch-case rausgesprungen wird, sondern jede der case-blöcke abgearbeitet wird. default ist im Prinzip nichts anderes als das else bei der if anweisung. Wenn nichts von den oberen Werten in der Variable enthalten ist wird die default-anweisung ausgeführt.

Aufgabe
Versucht die Aufgabe von oben mit der Switch-Case Anweisung zu lösen.

Sollte es noch Fragen zu dem thema geben bitte einfach wie immer in diesem Thread melden. Ich bin mir nicht sicher ob das alles so gut erklärt ist, hab mich evtl. insgesammt etwas kurz gefasst... Aber vielleicht reichts ja auch

 

[Zerd]

Schleifen
Kommen wir zu einer neuen wichtigen Sache des programmierens: Schleifen.
Schleifen werden genutzt um gewisse Programmabschnitte mehrfach durchlaufen zu lassen ohne sie mehrfach hinschreiben zu müssen.

Es gibt in C++ drei verschiedene Schleifenarten:
while-Schleife
Syntax:

Initialisierung;
while(bedingung) {
Befehle;
}

Beispiel:

#include 
int main() {
int i=1;
while(i  std::cout  i = i+1;
};
return 0;
}

Diese Schleife läuft so lange bis i kleiner oder gleich 10 ist. Also wird die Schleife nicht mehr ausgeführt sobald i den Wert 11 annimmt.
Bei dieser Schleife wird erst die Bedingung geprüft und wenn die Bedingung erfüllt wird wird die Schleife ausgeführt.

do-while-Schleife
Syntax:

initialisierung;
do{
befehle;
} while(bedingung);

Beispiel:

#include 
int main() {
int eingabe;
int summe=0;
do {
std::cout  std::cin >> eingabe;
summe = summe + eingabe;
} while(eingabe != 0);
std::cout  return 0;
}

Im vergleich zur while-Schleife wird die do-while schleife mindestens einmal ausgeführt. D.h. die BEdingung wird erst am ende geprüft. Die Schleife läuft also einmal durch und danach wird die eingabe überprüft. Ist die zuletzt eingegebene Zahl nicht 0 wird die Schleife nochmal durchlaufen und die zahl zu dem ergebnis addiert.

for-Schleife
Syntax:

for(initialisierung; bedingung; weiter) {
befehle;
}

Beispiel:

#include 
int main() {
int i;
for(i=1; i  {
std::cout  };
return 0
}

Die for schleife nutze ich persönlich am meisten, da sie meiner meinung nach die kürzeste und übersichtlichste ist, da die initialisierung des zählers im Schleifenkopf passiert.

Als Übung fällt mir gerade nicht wirklich was ein
Aber ihr könntet z.B. so ein programm schreiben:
Lies eine Zahl ein die als obere Grenze gilt.
Schreibt nun eine Schleife die von 0 bis zu dieser oberen Grenze läuft und alle Primzahlen ausgibt die bis zu dieser oberen Grenze vorkommen.

Bei Fragen, Problemen, Anregungen wie immer Hier melden

*edit*
Kleine Info: Ich versuch am Wochenende weiter zu machen, hab aber im Moment wenig zeit, ansonsten gehts nächste Woche weiter!

Funktionen
Ab einer gewissen programmgrösse kann es leicht unübersichlich werden. Eine möglichkeit das zu verhindern ist die verwendung von Funktionen.
Dabei werden gewisse Programmteile in Funktionen "ausgelagert".
Beispiel:

#include

/** Funktion zum addieren von zwei Zahlen */
int addiere(int a, int b) {
return a+b;
}

/** Main funktion */
int main() {
int eingabe1, eingabe2;
std::cout  std::cin >> eingabe1;
std::cout  std::cin >> eingabe2;
std::cout  return 0;
}

Dieses Beispiel ist relativ bescheiden, verdeutlicht aber die funktionsweise von Funktionen. Die funktion addiere ist recht klein und man hätte die Addition auch direkt in der main funktion durchführen können, aber um so komplexer die berechnungen werden umso sinnvoller wird es diese in funktionen auszulagern.

Erklärung zum funktionsaufbau:
int addiere(int a, int b)
ist der Funktionskopf. Er gibt an welchen Rückgabetyp die Funktion hat (int) wie die funktion heisst (addiere) und welche übergabe parameter die funktion hat (int a, int b).
Also sieht die Syntax so aus:

Rückgabeparameter Name(Übergabeparameter1, Übergabeparameter2, ...)

Die Übergabeparameter sind kopien der Werte die beim Funktionsaufruf in der main funktion übergeben werden. Diese Art der parameterübergabe nennt man "Call by Value". Es gibt neben dieser Variante auch noch "Call by reference" darauf werde ich aber erst später eingehen wenn wir zu Zeigern und Referenzen kommen.
Mögliche Übungsaufgabe:
Taschenrechner um Funktionen erweitern. neben den standard berechnungen könnten noch eine Funktion zum potenzieren und zum Berechnen der Fakultät implementiert werden.

Rekursion
Eine Rekursive Funktion ist eine Funktion die sich zum lösen eines Problems selber aufruft. Eine normale Funktion heisst im vergleich Iterativ.
Beispiel:

/** Summe der zahlen von n - 0 
also bei z.B. n = 5 würde die berechnung 5+4+3+2+1 lauten */
int sum(int n)
{
if(n==0)
return 0;
else
return n+sum(n-1);
}

/** Main funktion: Berechnet 5+4+3+2+1 */
int main() {
std::cout [code=php]void test(int a, int b) {
b = a;
a = 5;
}

int main() {
int varA = 1, varB = 2;
test(varA, varB);
std::cout  return 0;
}

Das beispiel Zeigt das sich die Original werte nicht verändern. Um mit den originalvariablen arbeiten zu können brauchen wir Zeiger.

Zeiger
So nun wirds mal etwas komplizierter
Vielleicht ist es nicht so klever mit so einem Satz ein neues Kapitel zu beginnen, aber hey, Ihr lasst euch sicher nicht einschüchtern!!

Was sind Zeiger?
Na mal sehen ob ich die richtigen Worte finde um Zeiger zu erklären...

Wie ihr vielleicht wisst wird der Speicher im Rechner in Byte eingeteilt. Jedes Byte hat eine eindeutige Speicheradresse. Wird einer Variablen eine Zahl zugewiesen so wird diese Zahl an einer bestimmten Adresse im Speicher abgelegt. Im vergleich zu dieser Art des speicherns von Daten speichert ein Zeiger nicht den Inhalt der Variable, sondern die Speicheradresse.

"Zeiger" zeigt auf die Adresse der Variable A

Belegt eine Variable mehr als einen Byte wird die Adresse des Zeigers auf das erste Byte gesetzt.

Wie benutze ich Zeiger?
Zum Anlegen von Zeigern wird der Dereferenzierungsoperator * verwendet:

int variable; // Normale Variable
int *pVariable; // Zeigervariable

Um an die Adresse einer Variable zu kommen benutzt man den Adressoperator &

int variable;
int *pVariable = &variable;

In diesem "zeigt" der Zeiger pVariable auf die Adresse von variable. (p vor dem pVariable steht für pointer)

Folgendes Beispiel soll die Funktionsweise noch etwas verdeutlichen:

int zahl;
int *pZahl = &zahl;

*pZahl = 5;
std::cout code]
Im prinzip folgen wir durch Angabe des * (Dereferenzierungsoperators) dem Zeiger und speichern am ende des Zeigers den Wert 5. Wenn wir nun die Variable zahl ausgeben werdet ihr sehen das der Wert 5 ausgegeben wird obwohl wir die variable zahl nicht direkt verwendet haben.

[size=5]Zeigervariablen übergeben[/size]
Um das "call by value" Beispiel mit hilfe von Zeigern so zu verändern das die originalwerte tatsächlich verändert werden muss es wie folgt verändert werden:
[code=php]void test(int *a, int *b) {
*b = *a;
*a = 5;
}

int main() {
int varA = 1, varB = 2;
test(&varA, &varB); // Übergabe der Adressen der Variablen
std::cout  return 0;
}

Die variablen varA und varB werden nun in der funktion test() verändert da die adressen der Variablen übergeben wurden.

Anmerkung:
Eigentlich sollten nun auch Referenzen erklärt werden... Ich werde das aber erstmal weglassen, da es nur eine andere (meiner meinung nach unschöne) möglichkeit ist Zeigeradressen zu übergeben. Vielleicht erweitere ich den Part hier irgendwann mal Oder vielleicht kommen ja auch beschwerden das das fehlt, dann mach ich da vielleicht noch was

Übung:
1. Schreibt eine Funktion die zwei Zahlen miteinander vertauscht. Dabei soll ein Zeigeraufruf verwendet werden.

int a = 4;
int b = 8;
swap(&a, &b);
...

Nach dem funktionsaufruf sollte also in a der Wert 8 und in b der Wert 4 gespeichert sein.

2. Schreibt eine Funktion die 3 Zahlen sortiert:

int a = 8;
int b = 4;
int c = 5;
sort(&a, &b, &c);
...

Nach dem Funktionsaufruf sollte also in a der wert 4, in b der wert 5 und in c der Wert 8 abgespeichert sein.

Sorry das meine Übungsaufgaben nicht so kreativ sind, aber vielleicht fallen euch ja noch ein paar ein

Probleme, Fragen und Anregungen bitte wie immer hier: http://www.freesoft-board.to/f155/diskussionsthread-zum-c-c-workshop-von-zerd-205639.html

P.S. Ich habe keine der programmzeilen die ich da oben geschrieben habe ausprobiert, von daher bitte ich Tippfehler zu entschuldigen

 

[Xbelt]

Danke an Zerd, dass ich sein Tut weiterschreiben darf

Bisher haben wir nur Angeschaut was man in C++ standardmässig benutzen kann, doch vielleicht wollt ihr auch einmal den Code auf mehrere Dateien aufteilen. Genau hier kommen die Präprozessor-Direktiven zum Einsatz.

Der Präprozessor
Bevor ein C++-Quellcode vom Compiler übersetzt wird, fasst der Präprozessor String-Literale zusammen, entfernt Zeilenumbrüche, löscht Kommentare, sowie alle Leerzeichen. Der Programmiere kann dem Präprozessor jedoch Anweisungen geben. Diese nennt man Präprozessor-Direktiven. Zeilen, welche für den P (präprozessor) bestimmt sind, beginnen mit dem Hash-Zeichen „#“. Eine Spezialität der PD (Präprozessor-Direktiven) ist, dass die Zeilen nicht mit einem Semikolon abgeschlossen werden.
So genug gelabert. Was kann man nun damit tun?

Bedingte Kompilierung
Wenn man eine Anwendung schreibt, welche Platformunabhängig ist, muss man unter Umständen verschiedene Header Dateien einbinden. Oder wenn man eine Anwendung erstellen will, welche je nach Sprache andere Header braucht, benutzt man folgende Befehle:
#if, #ifdef, #ifndef, #elif, #else, #endif
Nun anhand von den Namen kann man schon auf die Funktion der verschiedenen Befehle schliessen.
#if und #else sind meiner Meinung nach selbsterklärend, ebenso wie #endif.
#ifdef überprüft, ob der Ausdruck danach dem Präprozessor schon bekannt ist. #ifndef bewirkt genau das Gegenteil.
Schliesslich noch #elif. #elif entspricht dem Befehl else if.

Einbinden von weiteren Quellcodedateien
Eine weitere PD haben wir schon von Anfang an benutzt:

#include  //Die Include-Anweisung bindet eine weitere Quellcodedatei ein

Das Beispiel der Header Datei
Wenn wir nun eine eigene Headerdatei geschrieben haben, z.B. myheader.h, müssen wir diese in der main.cpp einbinden um deren Inhalt zu benutzen. Weiter wird in der Header Datei überprüft ob dieses schon eingebunden wurde um ein doppeltes einbinden zu verhindern. Das ganze würde dann so aussehen:

//myheader.h
#ifndef MYHEADER_H_
#define MYHEADER_H_
… irgendwas
#endif

//main.cpp
#include “myheader.h” // Wenn wir den Headernamen in “” angeben, sucht der Compiler die Datei im Arbeitsverzeichniss.
#include 
…

Überprüfung des aktuellen Betriebsystems
Diesen Code werde ich nicht weiter erläutern, denn er sollte eigentlich klar sein.

#include 
#ifdef __WIN32__
#define BS "Windows"
#elif __linux__
#define BS "Linux"
#else
#define BS "Unbekanntes Betriebssystem"

int main(){
std::cout  return 0;
}

Hier noch die weiteren Konstanten und für welches BS diese stehen:

__WIN32__ | Windows ab 95
__OS2__ | OS2
_Windows | Zielsystem Windows
__NT__ | Windows NT
__linux__ | Linux
__FreeBSD__ | FreeBSD
__OpenBSD__ | OpenBSD
_SGI_SOURCE | SGI-IRIX mit Extension *.sgi
_MIPS_ISA | SGI-IRIX
__hpux | HP-UX

Diese Konstanten sind nicht im C ++ Standard definiert sondern in speziellen Windows- bzw. Linux Headern oder in den IDE-Project settings. (Bei Visual C++ Express Edition sind diese in die IDE integriert)


Makros

#define Zahl 5
…
int main(){
int i;
i = 5 + Zahl;
std::cout / i hat den Wert 10;
#undef Zahl 
i = i – Zahl; //Fehler, da Zahl nicht mehr existent
return 0;
}

Weiter können auch Makros Parameter enthalten:

#include 
#define ADD(x,y) (x+y)
usw.

weiter kann man auch Makros über mehrere Zeilen hinweg schreiben:

#define Tausche(x,y) {\
int j; \
j=x; \
x=y;\
y=j;\
}

wichtig ist einfach, dass man jede Zeile mit einem "\" abschliessen muss (darum habe ich kein php codes verwendet, da diese "\" ignorieren).

ich habe keinen Quellcode ausprobiert. Fehler bitte bei mir melden.

Übungen:
1. Versucht einmal die climits einzubinden und die Konstante LONG_MIN und LONG_MAX auszugeben. (cout 2. Versucht einen Code zu schreiben, der je nach BS andere Header einbindet(welche ist eigentlich egal).
3. Schreibt ein Makro, welches eine Zahl mit sich selbst multipliziert und auch so aufgerufen werden kann:
SQRE(x+1)
Schwierig:
4. Schreibt ein Makro, welches die grössere von 2 Zahlen herausfindet und dies mit nur 1ner Anweisung. Informiert euch über ternäre Operatoren
Noch ein paar Übungen aus einem Buch:
1. Bestimmt und korrigiert die Fehler in folgenden #define- Direktiven:
a) define BEGIN {
b) #define LIMIT 1000
c) #define START = 1
d) #define CUBE (n * n * n)

 

[ro2000]

Hallo Zerd,
danke für die Hilfe, mit der Image Datei hat die Installation der SDK Plattform funktioniert. Hab dann gleich mal die Programme aus deinem Workshop ausprobiert und versucht die Übungsaufgabe zu lösen:

#include

int main() {
int eingabe1;
int eingabe2;
int eingabe3;
int ergebnis;
std::cout std::cin >> eingabe1;
std::cout std::cin >> eingabe2;
std::cout std::cin >> eingabe3;
ergebnis = eingabe1 + eingabe2 + eingabe3;
std::cout return 0;
}

Ich freue mich schon auf die Fortsetzung
Gruß ro2000

 

[Zerd]

Hi ro2000,
spontan sieht der quellcode gut aus. Was man optimieren kann (muss man aber nicht) ist folgendes:

int eingabe1;
int eingabe2;
int eingabe3;
int ergebnis;

kann man in eine Zeile schreiben:

int eingabe1, eingabe2, eingabe 3, ergebnis;

Solange alle Variablen den selben Typ haben sollen (in dem Fall int) können alle definitionen der Variablen in eine Zeile geschrieben werden.

Außerdem solltest du wenn du quellcode postest die [ php] [/ php] tags verwenden damit die Formatierung nicht verloren geht. (auch wenn wir nicht in PHP programmieren ist die Formatierung schöner)

Tut mir leid das ich dieses Wochenende nicht weitermachen kann, dafür wirds ab nächster Woche umso interessanter.

 

[ro2000]

Hallo Zerd,
danke für die bisherigen Beiträge im Workshop. Ich denke das im Hintergrund einige deinen Workshop verfolgen. Lass dich nicht entmutigen und mach bitte weiter. 1 bis 2 Beiträge pro Woche reichen sicherlich aus um nicht in Stress zu geraten und um den Anschluss nicht zu verlieren.
Gruß ro2000

 

[ElvisTheKing]

Sensationell!!!
Zuerst hilft er einem bei den Delphi-Hausaufgaben, dann schreibt er einen grandiosen Einstieg in C++ und bald hat er schon seine eigene Programmiersprache entwickelt!
Ich verehre dich Zerd!

mfg

 

[Feuerstein]

ich wäre sehr daran intressiert

na dann mach mal die augen auf

http://www.freesoft-board.to/f155/c-workshop-von-zerd-205683.html

 

[ro2000]

Hallo Zerd,
ich habe da ein Problem, wenn ich das nachfolgene Programm von dir kompiliere,

#include 
#include 

int main() {
std::string nachName;
cout  cin >> nachName;
cout  return 0;
}

erhalte ich diese Fehlermeldungen:

error C2065: 'cout': nichtdeklarierter Bezeichner
error C2065: 'cin': nichtdeklarierter Bezeichner

setze ich aber vor cout u. cin das std:: dann läuft es ohne Fehler durch. Woran liegt das?
Gruß
ro2000

 

[Zerd]

Oh, danke für den Hinweis
Das passiert wenn man die Programme die man in einem Kurs veröffentlicht nicht testet sondern nur as dem Gedächtnis aufschreibt

du hast recht das in dem fall std:: davor muss, weil genau wie string cin und cout in dem namespace std definiert sind.

Wenn du nicht jedes mal std:: davor schreiben möchtest musst du unter die #include anweisungen
using namespace std;

schreiben. Dadurch definierst du das der compiler automatisch im namespace std nachschaut. Ich habe den fehler im workshop berichtigt.. danke für die Anmerkung

 

[ro2000]

Hallo Zerd,
aller Anfang ist schwer. Ich hänge mal wieder, und zwar habe ich folgendes Problem in der Zeile mit der if Anweisung:

test1.cpp(15) : error C2059: Syntaxfehler: ')'

Ich wollte das Programm mit dem Taschenrechner schreiben aber beim kompilieren taucht ein Fehler auf mit dem ich nichts anfangen kann. Habe schon alles mögliche ausprobiert, aber ich komme nicht drauf. Den Rest vom Programm habe ich erst mal als Kommentar markiert. Wenn ich das Semikolon nach der Klammer nicht setze, habe ich eine Fehlermeldung mehr.

#include 
#include 

using namespace std;

int main() {
int eingabe1, eingabe2, ergebnis;
string Rechenart;
cout  cin >> eingabe1;
cout  cin >> eingabe2;
cout ]aus: ";
cin >> Rechenart;
if (Rechenart==+); 
{
ergebnis = eingabe1 + eingabe2;
} 
/*if(Rechenart==-) {
ergebnis = eingabe1 - eingabe2;
}
if(Rechenart==*) {
ergebnis = eingabe1 * eingabe2;
}
if(Rechenart==/) {
ergebnis = eingabe1 / eingabe2;
}*/
cout return 0;
}

Ich hoffe du kannst mir weiterhelfen
gruß
ro2000

 

[Zerd]

Hey, kein Problem, dafür ist der Thread doch da Und wenigstens seh ich dann das immerhin einer meinen workshop verfolgt Danke dafür schonmal!

Das Problem ist folgendes:
C++ sieht die zeichen + - * / als operatoren. d.h. der compiler schaut sich deine syntax an und merkt das etwas nicht stimmt weil er den operator ==+ nicht kennt bzw. ein zweites Argument fehlt. (In dem fall kennt er den operator ==+ nicht weil es ihn einfach nicht gibt.)

Was du machen möchtest ist ein einzelnes Zeichen überprüfen was du vorher eingegeben hast. Einzelnes Zeichen = Character = char. Ein char wird so definiert:

char variable = 'a';

was du also machen musst um deine Eingabe zu überprüfen ist statt

if(Rechenart==+)

musst du

if(Rechenart=='+')

benutzen.

Das semikolon was du hinter der if abfrage stehen hast muss ebenfalls weg, da das soviel beduetet wie "keine Anweisung". Durch das semikolon wird die if abfrage quasi ignoriert und die nachfolgenden anweisungen in jedem Fall ausgeführt.

Ich hoffe die erklärung war ausreichend
Gruß Zerd

 

[ro2000]

Danke für deine Hilfe Zerd,
habe es mit deinen Hinweisen nach einiger Zeit geschafft, dass das Programm so läuft wie ich es mir vorgestellt habe. Mit der Anwendung der char Variablen hatte ich etwas Verständnissprobleme gehabt, aber jetzt habe ich es kappiert. Manchmal steht man einfach auf der Leitung.
Bei den Übungsaufgaben merkt man erstmal wo der Hund begraben liegt.
Jetzt gehe ich mal weiter im Text von deinem Workshop, damit ich aufs Laufende komme.

 

[Megamen]

Hi
ich muss auch dringend mal C++ proggen (wegen Studium und so)
und bräuchte noch das Windows Platform SDK.
Hab aber keine gültige WGA um das bei MS zu laden.
Könnte einer vielleicht das Iso mal uppen?

Ich könnte es dann bei Bedarf auf mehr Usern zur Verfügung stellen
dank RS Prem. Acc.

Megamen

Ok, da ich das SDK noch nicht laden konnte, benutze ich erst einmal
Dev-C++ zum programmieren.

Ich hab mich an dem Taschenrechner versucht, aber es will sich nicht
kompilieren lassen!
Vielleicht weiß einer wo das Problem liegt.

#include 
#include 


using namespace std;

int main(int argc, char *argv[])
{
int a,b,c;
char operator;

std::count  std::cin >> a;
std::count  std::cin >> b;
std::count  ) "  std::cin >> operator;

if (operator=='+'){c=a+b};
if (operator=='-'){c=a-b};
if (operator=='*'){c=a*b};
if (operator=='/'){c=a/b};

std::cout  return (0); 
}

An der Zeile char operator gibt er ein Problem aus.



Noch eine Frage:
Kann man zur Absicherung gegen falsche Eingaben dann noch so etwas
hinzufügen?

if (operator <> '+' or '-' or '*' or '/')
{std::cout  wählen!";};

Ich glaube das ist noch nicht sehr schlau umgesetzt, aber ihr versteht bestimmt was ich meine.


Megamen

 

[Zerd]

std::count  ) "

An der Zeile char operator gibt er ein Problem aus.

Das Richtig wäre:
std::cout ) ";

Noch eine Frage:
Kann man zur Absicherung gegen falsche Eingaben dann noch so etwas
hinzufügen?

if (operator <> '+' or '-' or '*' or '/')
{std::cout  wählen!";};

Du könntest in dem fall mit if-else blöcken arbeiten und in dem letzten else Block die Ausgabe machen. Des weiteren darfst du operator nicht als variablen namen nehmen weil das ein reservierter bezeichner ist der in C++ bei Klassen benutzt wird. Dazu komme ich im Workshop bald. Du hast aber auch das Semikolon hinter die geschweifte klammer gesetzt, das muss immer direkt hinter die Anweisung, also so:

if (op=='+'){ c=a+b; }
else if (op=='-'){ c=a-b; }
else if (op=='*'){ c=a*b; }
else if (op=='/'){ c=a/b; }
else { std::cout  wählen!"; }

Das ganze lässt sich mit der switch-case anweisung etwas eleganter lösen, da es da den default-block gibt.

Du solltest deine Formatierung vielleicht nochmal überdenken, ist etwas unübersichtlich... Aber lass dich nicht entmutigen, bleib am Ball, dann gehts bald besser!

Also viel spaß weiterhin
Zerd

 

[Megamen]

Das mit der case anweisung mach ich gleich, erstmal if testen.
Das mit dem count hab ich übersehen, sry.

Das Semikolon hinter der geschweiften klammer hab ich auch nicht erkannt.
Das mit der variable operator war scheinbar unglücklich gewählt.
Danke.

Aber wenn ich einen falschen Operator eingebe wird der alternativ Satz
ausgegeben, aber dahinter gleich das Ergebnis. Außerdem ist
das Erbegnis trotzdem eine große Zahl.

else { std::cout  wählen!"; };

std::cout

Bei falscher Eingabe kommt also:
Bitte nur zwischen den Operatoren + - * / wählen!
Ergebnis: 2293672



Megamen

PS: ok, hab das mit std::endl; erst jetzt kapiert. Das ganze steht also nicht mehr auf einer Zeile.

 

[Zerd]

Bei falscher Eingabe kommt also:
Bitte nur zwischen den Operatoren + - * / wählen!
Ergebnis: 2293672

Oh sorry das hab ich übersehen
Du könntest entweder das Ergebins am anfang mit 0 initialisieren:
int c = 0;

Dann steht bei einer falschen Eingabe eben immer:
Ergebnis = 0

Oder du machst es zusätzlich so wie du schon am Anfang machen wolltest:

if(op == '-' || op == '+' || op == '*' || op == '/')
std::cout else
std::cout  wählen!";

Es gibt eigentlich immer verschiedene Lösungen.

 

[Megamen]

Danke.
Werd mich bald mal an den Schleifen versuchen.

Megamen

 

[Rebell]

hallo, ich habe auch viel intersse an dem tutorial, das du dankenswerter weise schreibst, nun aber mein pronblem, ich kann das Windows Platform SDK aber genau wie megamen nicht downloaden, ich hoffe das es noch jemand uppen kann THX.

rebell

 

[Zerd]

Ich hab leider nicht eher geschafft danach zu suchen, aber der Download der platform SDK funktioniert ohne Validation:

h++p/www.microsoft.com/downloads/details.aspx?FamilyID=d8eecd75-1fc4-49e5-bc66-9da2b03d9b92&displayLang=en

Im moment ist es zeitlich was eng bei mir, aber der workshop wird bald weitergehen!

 

[zarder]

Toll !

du hast mein Weltbild zerstört:

1. ich dachte es gibt keine netten, hilfsbereiten Menschen mehr.
2. es gibt nix gutes umsonst.

ich bin echt sprachlos! so ein gutes tut auf deutsch hab ich schon lange gesucht!!! zeugt schon von echten Kenntnissen!!

VIELEN DANK für diese Klasse Arbeit! Mach weiter so!

mfg
Alex

 

[Zerd]

Danke für die netten Worte. Leider gab es auch negativ feedback (allerdings nur per PM - KA, vielleicht zu feige), war aber nicht der Rede wert.

Mir ist grad aufgefallen das schon ein Monat vergangen ist seit dem ich am workshop weitergemacht hab. Die Zeit vergeht echt mal schnell wenn man viel zu tun hat... Ich versuche bald weiter zumachen. Ich weiß allerdings auch nicht wirklich ob die leute die am Workshop teilnehmen überhaupt schon alles durch haben, hat schon jemand die letzte Aufgabe gelöst??

 

[zarder]

ich hab deine workshop zwar erst vor kurzem entdeckt, aber schon alles durchgelesen ....

die letzte Aufgabe konnte ich leider nicht lösen, da mir nie jemand was über die Fibunacci Folge erzählt hat (leider nur Mathe Grundkurs). Wikipedia hat mir da auch nicht wirklich weitergeholfen .

aber ich hab mich mal an der rekursiven fakultät hab ich mich mal versucht:

#include 
#include 

int fak(int n){

if (n==1)
return 1;

else
return n*fak(n-1);

}

int main(int argc, char *argv[])
{
int x;
std::cout  std::cin >> x;
std::cout  return EXIT_SUCCESS;
}

außerdem habe ich (glaube ich) einen kleinen Fehler bei dir entdeckt: bei dem Beispiel für Rekursion hast du in der Zeile: std::cout << "sum(5) = " sum(5); die
herzlichen Dank für die bisherigen Kapitel!

ich würde mich riesig freuen, wenn du ein bischen Zeit für weitere Kapitel finden könntest!

mfg
Alex

 

[Zerd]

Danke für den Hinweis, ich habe den Fehler berichtigt!

Falls du interesse hast die letzte Aufgabe von mir zu lösen ein kleiner Hinweis:

Ich habe ja schon bei der Aufgabenstellung die Regeln der Fibonacci Folge hingeschrieben:
F(1)=1
F(2)=1
F=F(n-1)+F(n-2)

F ist dann wie man vielleicht vermuten kann die Funktion und das in Klammern dahinter ist der Parameter.

Diese Fibonacci folge recht nett durch rekursion zu lösen.

Also prinzipiell musst du in der funktion F den wert N prüfen
Wenn F(1) -> return 1
Wenn F(2) -> return 1
sonst -> return F(n-1) + F(n-2)

 

[Black Bull]

Hallo,
ich mache auch deinen Workshop und finde es super, dass du das machst! Vielen Dank!

Ich habe jetzt nur leider auch beim Taschenrechner Probleme. Indem ich versucht habe, am Anfang char-Variablen einzufügen, habe ich die Fehler von 87 auf 1 verringert, aber dann sagt er mir, er finde keine Datei namens char/character:

#include 
#include 
#include 

using namespace std;

int main() {
int eingabe1, eingabe2, ergebnis; 
char '+', '-', '*', '/';
string Rechenart;
cout  cin >> eingabe1;
cout  cin >> eingabe2;
cout ]: ";
cin >> Rechenart;
if(Rechenart=='+') {
ergebnis = eingabe1 + eingabe2;
}
if(Rechenart=='-') {
ergebnis = eingabe1 - eingabe2;
}
if(Rechenart=='*') {
ergebnis = eingabe1 * eingabe2;
}
if(Rechenart=='/') {
ergebnis = eingabe1 / eingabe2;
}
cout  return 0;
}

Habe da schon so einiges ausprobiert, ich glaube so kommt es der Lösung am nächsten...
Wär cool, wenn du mir da helfen könntest.

Mfg
Black