[FONT="Comic Sans MS"][COLOR="DeepSkyBlue"][SIZE="3"]Hallo Core'lers.
Nach den Rückschlägen im C++ Bereich (Schlechte Guides/Bessere Guides aber grottig erklärt usw) habe ich mich nach reiflicher Überlegung (und aus Langeweile) dazu entschlossen, meinerseits mal bissl was zu schreiben.
Hoffe der Guide kommt gut an bei euch und ihr lernt auch was draus^^

Um die Übersicht zu wahren, mache ich hier im Anfangspost ein Inhaltsverzeichnis, die Kapitel werden als neuer Post veröffentlicht.

#Kapitel und Rest folgen gleich[/SIZE][/COLOR][/FONT]

Vorbereitung

[FONT="Comic Sans MS"][COLOR="DeepSkyBlue"][SIZE="3"]Fangen wir an:
Alle Wörter, welche so aussehen: [COLOR="PaleTurquoise"]Wort[/COLOR], findet ihr im Glossar wieder, mit

einer Erklärung.

[COLOR="Lime"]Vorbereitung:[/COLOR]
Was brauchen wir zum Anfang:
-Einen Editor und einen Compiler, ich Empfehle Visual C++ 2008 Express. Kostenlos und gut für alles was man so als

Hobbyprogrammierer brauch.
Es enthält:
-IDE (IntegratedDevelopementEnvironment, Integrierte Entwicklungsumgebung, also unser Editor)
-Compiler
-Linker (Er fügt alles soweit zu ner Exe zusammen, mehr dazu später)

-Augen (Sehr wichtig, nicht vergessen (Ironie muss sein!))
-Finger (Nach den Augen wohl das 2. wichtigste)
- Brain.exe (Google nutzen zum runterladen)

Denke das war mal alles zum Vorbereiten.
Installiert alles und startet Visual C++ (Nachfolgend entweder VC oder VC++ genannt zur Abkürzung)[/SIZE][/COLOR][/FONT]

Schritt 1:

[FONT="Comic Sans MS"][COLOR="DeepSkyBlue"][SIZE="3"][COLOR="Lime"]Schritt 1: Hallo Welt[/COLOR]
In jeder Programmiersprache hat es sich mittlerweile durchgesetzt: Das "Hallo Welt" (Englisch: Hello World) Programm
Da es soweit eigentlich immer vorgeschlagen wirs als erstes, fange ich auch damit an.

Also wenn VC++ gestartet ist, wählt ihr oben im Menü den Punkt "Datei" aus.
Es folgen Klicks auf:
-"Neu" -> "Neues Projekt"
-"Leeres Projekt"
Danach gebt unten noch einen Namen für das Projekt ein.
Nennt es "Hallo Welt" oder gebt ihm einen anderen Namen, solange ihr es wiederfindet.

Normalerweise solltet ihr nun links den Projektmappenexplorer finden, der 3 Ordner enthält:
-Headerdateien
-Quelldateien
-Ressourcendateien

Falls ihr euch fragt, wozu der Projektmappenexplorer dient, sage ich euch, dass er sämtliche Dateien enthält die in eurem Projekt vorkommen.
Das heißt er hat alle Dateien die ihr zu dem Projekt hinzufügt, unter einer haube, um euch die Sache zu vereinfachen.

Macht nun einen Rechtsklick auf "Quelldateien".
Nun auf "Hinzufügen" -> "Neues Element"
Wählt nun den Punkt "C++-Datei (.cpp)" aus.
Gebt der Datei einen Namen, zB Main oder einen anderen aussagekräftigen Namen.
Klickt nun auf OK.
Ihr solltet nun links im Ordner "Quelldateien" eure Datei "Dateiname.cpp" (Dateiname = Der Name eurer Datei) finden.
Ausserdem sollte nun ein Fenster neben dem Projektmappenexplorer sein, wo der Cursor drin blinkt.
Das ist euer Editorfenster, wo ihr sämtlichen Quellcode, den die "Dateiname.cpp" aufnehmen soll, reinschreibt.

In dieses Fenster schreibt ihr nun folgenden Code: (oder ihr fügt ihn per Copy&Paste ein, ihr faulen Leute xD)
Sämtlicher Code wird von mir getestet unter den gleichen Voraussetzungen die ihr habt, sofern ihr VC++ installiert habt.
Daher sollte er funktionieren.
Bei anderen Compilern bin ich mir nicht so sicher, da es ganz drauf ankommt ob sich diese überhaupt an den ANSI-Standard halten.
(Mehr zum ANSI-Standard --> Google)

Nun drückt F5.
Dies sorgt dafür, dass VC++ alles nötige tut um den Quellcode zu kompilieren und ihn in eine auführbare Exe zu verwandeln.
Mehr dazu was da genau passiert, gibts später.

Erklärung des Codes:
-[COLOR="RoyalBlue"]#include[/COLOR]: [COLOR="RoyalBlue"]#include[/COLOR] ist eine so genannte Präprozessoranweisung.
Der Präprozessor ist ein eigenständiges Programm, welches noch vor dem Compiler gestartet wird und den Quellcode nach solchen Anweisungen durchsucht.
Es gibt viele Präprozessoranweisungen, sie beginnen alle mit einem # (Mehr Anweisungen werdet ihr noch irgendwann kennenlernen)
In unserem Fall geht der Präprozessor hin und kopiert den Inhalt der Datei "iostream", welche sich in einem Verzeichnis mitten im Installationsverzeichnis von VC++ befindet, in unseren Quellcode.
Nach dem Präprozessor folgt dann der Compiler und übersetzt unser Programm in [COLOR="PaleTurquoise"]Maschinencode[/COLOR]

-[COLOR="RoyalBlue"]using namespace[/COLOR] [COLOR="Silver"]std[/COLOR]:
"[COLOR="RoyalBlue"]using namespace[/COLOR] [COLOR="Silver"]std[/COLOR]" gibt dem Compiler an, den Namespace [COLOR="Silver"]std[/COLOR] zu nutzen.
Namespace steht für Namensraum und hilft euch und dem Compiler in einem großen Projekt die Übersicht zu wahren.
Dadurch, dass man Funktionen mehrfach belegen kann, (dies lernt ihr noch später in einem anderen teil) verliert man schnell mal die Übersicht und man müsste dauernd gucken was zu was gehört usw.
Um dann aber ohne viel suchen und vorallem ohne Fehler eine mehrfach belegte Funktion so zu nutzen, wie man will, gibts Namensräume.
Im Falle von [COLOR="RoyalBlue"]cout[/COLOR] müsste man normalerweise schreiben: std::cout , um kenntlich zu amchen dass man die Funktion cout aus dem Namensraum std benutzen möchte.
Das [COLOR="Silver"]std[/COLOR] steht dabei für Standard und meint die Funktionen die bei VC++ schon installiert waren.
Da aber ein dauerndes [COLOR="Silver"]std[/COLOR]::[COLOR="RoyalBlue"]cout[/COLOR] (genauso: std::cin usw) nervt, benutzt man das wort [COLOR="RoyalBlue"]using[/COLOR] in Verbindung von [COLOR="RoyalBlue"]namespace[/COLOR] gefolgt von dem Namen des Namespaces, den man nutzen möchte.

-[COLOR="RoyalBlue"]cout[/COLOR]:
[COLOR="RoyalBlue"]cout[/COLOR] steht für [COLOR="RoyalBlue"]C[/COLOR]onsole[COLOR="RoyalBlue"]OU[/COLOR]tpu[COLOR="RoyalBlue"]T[/COLOR] und bedeutet Konsolenausgabe.
In unserem Falle gibt [COLOR="RoyalBlue"]cout[/COLOR] den [COLOR="PaleTurquoise"]String[/COLOR] Hallo Welt aus.
Das "<<" gibt dabei den Befehl, den String "Hallo Welt" in das Objekt [COLOR="RoyalBlue"]cout[/COLOR] zu schieben, damit es auf dem Bildschirm erscheint, da [COLOR="RoyalBlue"]cout[/COLOR] immer mit einem Ausgabeobjekt (In diesem Falle der Monitor) verbunden ist.
[COLOR="RoyalBlue"]cout[/COLOR] steht immer mit einem Ausgabeobjekt, also einer Datei, dem Bildschirm und weiteren Ausgabemedien in Verbindung.
Auf die selbe Weise nutzen wir "<<" um [COLOR="Silver"]endl[/COLOR] auf [COLOR="RoyalBlue"]cout[/COLOR] zu schieben.

-[COLOR="Silver"]endl[/COLOR]:
[COLOR="Silver"]endl[/COLOR] steht für EndLine und bedeutet Linienende und meint damit das Ende einer Zeile in der Konsole.
Würde ich diesen Parameter nicht nutzen, so würde alles was in der Konsole stehen würde, in einer Zeile sein.

-[COLOR="Silver"]cin.get[/COLOR]:
[COLOR="Silver"]cin.get[/COLOR] steht dafür in diesem Quelltext, damit sich die Konsole nicht nach dem Start schliesst.
Normalerweise wäre für den Computer schon nach dem abarbeiten von [COLOR="RoyalBlue"]cout[/COLOR] das Ende des Programms erreicht, bzw eigentlich nach dem [COLOR="RoyalBlue"]return[/COLOR] [COLOR="Silver"]0[/COLOR].
Allerdings sorgt das [COLOR="Silver"]cin.get[/COLOR] dafür dass das Programm auf eine Usereingabe wartet, in diesem Falle auf das Drücken der Entertaste.
Durch diesen Schritt können wir die Ausgabe lesen und das ist doch unser Ziel oder?

-[COLOR="RoyalBlue"]return[/COLOR] [COLOR="Silver"]0[/COLOR]:
Eigentlich nicht gebraucht, des sauberen Programmierens wegen aber immer gern benutzt sorgt dieser Befehl lediglich dafür, einen Wert an das Betriebssystem zurückzugeben.
In diesem Falle den Wert 0 was für "Programm sauber beendet" steht. (0 ist nicht immer dafür da, es gibt auch andere Rückgabewerte, kommt auf den Programmierer an).
Auf den Befehl [COLOR="RoyalBlue"]return[/COLOR] komme ich zu einem späteren Teil wieder zurück.

Dies war eigentlich soweit die Erklärung des Codes.
Jedoch, ich habe noch wichtige Dinge vergessen, die nun folgen:

-[COLOR="RoyalBlue"]int[/COLOR] [COLOR="Silver"]main()[/COLOR]
Dies ist eine Funktion, die in jedem! Programm stehen muss und für den Einstiegspunkt ins Programm dient.
Diese Funktion wird vom Betriebssystem automatisch bei Programmstart geladen und danach wird halt der enthaltene Code ausgeführt, in unserem Fall unser Hallo Welt Programm.
Noch ein Hinweis zu main():
[COLOR="RoyalBlue"]int[/COLOR] ist die Bezeichnung des datentyps, den main() bekommt. Datentypen lernt ihr später kennen in Verbindung mit Variablen.
Lange Zeit benutzte man void, einen anderne Datentyp.
Jedoch mit Aufkommen des ANSI-Standards wurde festgelegt, dass man kein void mehr nutzen darf, es muss nun mindestens int benutzt werden.

- { } :
Diese geschweiften Klammern kennzeichnen einen Anweisungsblock.
Alle Funktionen in einem Anweisungsblock gehören zu der Funktion, die vor dem Anweisungsblock kommt (In unserem Programm die main() Funktion)
Diese geschweiften Klammern kommen nochmals im Gültigkeitsbereich von variablen zur Bedeutung, aber dazu mehr entweder von mir oder von Google bzw eurem C++ Buch, da mein Tutorial kein Buch ersetzen kann.

- ; (Semikolon)
Das Semikolon am Ende jeder Zeile ist euch sicher aufgefallen oder?
Ja denke ich schon.
Es sagt dem Compiler: " Hallo hier ist die Zeile (der Befehl) zu ende"
Ohne dieses ; würdet ihr einen Fehler vom Compiler erhalten, daher vergesst es nicht

So nun denke ich, dass ich soweit alles erklärt habe.
Dies war auch das erste Kapitel meines Guides, Kapitel 2 wird noch folgen.
Solltet ihr irgendwas vermissen oder sonstwas, so nutzt zur Referenzierung folgendes Stichwort: [COLOR="Yellow"]HW-TUT[/COLOR]
Beachtet auch die Hinweise in meinem anderen Thread für den Guide, direkt auf Seite 1.[/SIZE][/COLOR][/FONT]

KApitel 2: Variablen

[FONT="Comic Sans MS"][COLOR="DeepSkyBlue"][SIZE="3"]Hallo Leute,
Willkommen zu meinem 2. Kapitel meines C++ Guides.
Wie immer versuche ich alles so gut wie möglich zu erklären usw.

Das heutige Kapitel dreht sich um Variablen.
Zuersteinmal die Frage, was ist eine Variable?

Nun eine Variable kann man sich wie einen Topf vorstellen.
Nehmen wir als Beispiel mal einen Geldbeutel.
Auch er ist im Grunde eine Variable, denn er enthält einen Wert, nämlich den Wert des Geldes in ihm.
Genau diesen Zweck erfüllen Variablen, sie nehmen Werte auf und man kann auch mit den Werten rechnen.
Desweiteren kann man VAriablen auch als Platzhalter verwenden für Dinge, die sich ändern und daher noch nicht genau bestimmt werden können zur Zeit der Programmierung.
Werfen wir mal einen Blick auf folgenden Code:
Was euch sicher auffallen sollte, zumindest wenn ihr Kapitel 1 gelesen habt, ist, dass ich hier wieder das Wort int benutze.
Wie ihr sicher wisst, ist int ein Datentyp.
Es gibt verschiedene Datentypen in C++, hier mal soweit alle die ich kenne. (Dürften soweit die normalen Standardtypen sein, die man eh dauernd brauch. Keine Gewähr auf Vollständigkeit.):
Erklärung:
int: - Die klassische Ganzzahl, bzw dieser Datentyp kann ausschliesslich Ganzzahlen speichern, zB 1,2,3,4,5, ...
Float: - Für Gleitkommazahlen wie 1.5, 4.789 usw (Man benutzt in C++ generell einen Punkt statt dem Komma für Dezimalstellen, wegen der Englischen Schreibweise)
double: - Genau wie Float, jedoch mit einem größeren Wertebereich. (Mehr zu Wertebereich später)
long: - Noch größer, kann auch in Verbindung mit double und anderen Datentypen gebraucht werden.
char: - Wie der Name schon sagt nur für einen einzelnen Buchstaben bestimmt, also A,a,B,b,C,c
Strings in der Form gibt es in C++ nicht, aber man kann ein Array aus chars nutzen, um einen String zu speichern.
bool: - Ein Boolean oder bool wird immer dann gebraucht wenn es um Wahrheitswerte geht.
Damit meine ich nicht 0 oder 1, sondern True oder False
Dies ist der beste Datentyp, wenn man schnell mal Wahrheiten überprüfen will. (Damit kann man aber nicht den Freund/ die Freundin auf Lügen überprüfen, das geht leider nicht)

Nun aber weiter im Text.
Wie arbeitet man mit Variablen?
Nun, zuerst muss man die Variable kennzeichnen als solche, indem man den Datentyp, gefolgt von dem Namen der Variable im Quellcode notiert.
Beispiel: In diesem Fall wird die Variable Geldbeutel deklariert (=Bekanntgemacht).
Würde ich das nicht tun, so würde ich spätestens bei der ersten Verwendung einen Compilerfehler erhalten.
Man kann auch schon bei der Deklaration einer Variablen einen Wert zuweisen.
Dies geschieht über den Zuweisungsoperator =
Beispiel: In diesem Fall erhält die Variable Geldbeutel schon bei der Deklaration den Wert 5.

Nach der Deklaration einer Variable entfällt das Angeben eines Datentyps, dieser wird nicht mehr gebraucht.
Man kann nun mit einer Variable ganz normal rechnen, wie mit normalen Zahlen.
Beispiel:

Ausgabe:


Euch sind sicher die beiden Dinge [COLOR="YellowGreen"]/* */ [/COLOR] und [COLOR="YellowGreen"]//[/COLOR] aufgefallen?
Das sind [COLOR="YellowGreen"]Kommentare[/COLOR].
Ein [COLOR="YellowGreen"]Kommentar[/COLOR] wird beim [COLOR="PaleTurquoise"]Kompilieren[/COLOR] nicht mit einbezogen in das fertige Programm.
Sie dienen nur zur Erklärung von Programmteilen im Quelltext.
Dies ist wichtig, falls man seinen Quelltext anderen zeigen möchte, damit sie wissen, was wo geschieht.
Oder auch wenn man selber anch einiger Zeit wieder in einen Quellcode von sich schaut, damit man noch weiß, was man evt in einem Zustand geistiger Umnachtung in eine Datei geschrieben hat, so dass man sein Programm noch versteht.

Desweiteren sollten euch die Abkürzungen [COLOR="Silver"]+=[/COLOR] und [COLOR="Silver"]-=[/COLOR] aufgefallen.
Sie dienen der Kurzform von Addition und Subtraktion, ich könnte es auch so tun wie bei Multiplikation und Division, aber man hat diese Abkürzung eingeführt um nicht so viel tippen zu müssen.

Ansonsten kann ich zu meinem Beispielcode nur sagen, dass ich nach jeder Operation mit der Variable den aktuellen Wert ausgeben lasse.
Anmerkung: Der Code dieses Kapitels ist direkt hier im OFrum geschrieben worden, sollte er nicht funktionieren bitte ich um Rückmeldung, damit ich es beheben kann.

Zum Schluss noch eine weitere Verwendung von variablen.
Variablen kann man auch nutzen, um Usereingaben zu speichern.
Damit dies passiert, bedienen wir uns des Befehls [COLOR="RoyalBlue"]cin[/COLOR], was für [COLOR="RoyalBlue"]C[/COLOR]onsole[COLOR="RoyalBlue"]IN[/COLOR]put steht.
Angewendet wird es so:

Ausgabe:

Der Code sollte normalerweise selbsterklärend sein, der neue Befehl [COLOR="Silver"]cin[/COLOR] wurde per [COLOR="YellowGreen"]Kommentar[/COLOR] erklärt.
Eins noch zu [COLOR="Silver"]cin[/COLOR]:
[COLOR="Silver"]cin[/COLOR] verwendet, anders als [COLOR="RoyalBlue"]cout[/COLOR] den Operator ">>", um die Eingabe in die Variable zu schieben, bevor der Inhalt dann ausgegeben wird.

Dies war mein 2. Kapitel.
Das 3. Kapitel folgt zu einer anderen Zeit, doch es wird noch irgendwann kommen.

Das Stichwort für dieses Kapitel lautet: [COLOR="Yellow"]VAR-TUT[/COLOR]

Hoffe dieses Kapitel hat euch auch so gut gefallen wie das letzte Kapitel.
Wenn nicht, sagt Bescheid, gebt aber vorher das Stichwort an.[/SIZE][/COLOR][/FONT]