Datei heruntergeladen von: c-schell.de Index: 1. Vorwort 2. Der Compiler 3. Grundlagen 4. Variablen 5. Operatoren 6. Der Cast-Operator 7. Der Sizeof-Operator 8. Der Adress-Operator 9. Die logischen Operator 10. Bitweise Operator --------------------------------------- --------------------------------------- Vorwort (!!- bitte lesen - !!) ? In diesem Lernkurs lernst du die Grundlegenden Programmiertechniken von C++. Es wird hier kein Wert auf Vollständigkeit gelegt, da eine komplette Beschreibung von C++ in allen Einzelheiten weit über 3000 Buchseiten füllen würde. Schon alle Einzelheiten von reinem C++ (ohne die Windows- und Linuxprogrammierung) wäre ca. 1000 Seiten lang. Deshalb wird meine Beschreibung von C++ nicht jede Einzelheit erwähnen, dafür aber auch auf die Windows- und sogar auf die Linuxprogrammierung eingehen. Trotzdem dürftest du danach in der Lage sein eigene C++-Programme zu schreiben, allerdings denke ich, dass dein Wissen nicht ausreichen wird, um in der Praxis umfangreiche Windows-/Linux-Programme zu schreiben. Um es gleich Vorwegzunehmen: Unter Linux-Programmen verstehe ich Programme, die in der Linux-KDE 1) laufen, da zwischen Programmen, die in DOS oder der Linux-Konsole 2) laufen, fast kein Unterschied in der Programmierung besteht. Schließlich möchte ich dir meine Übliche Gestaltung der Seite zeigen. Wie du vielleicht schon bemerkt hast bedeuten hochgestellte zahlen, das am Seiten ende eine nähere Erklärung des Begriffs davor steht, wie z.B. Linux-KDE 1) . Codebeispiel kennzeichne ich immer so: #include void main() { cout << "Hallo, ich bin dein erstes Beispielprogramm\n"; } Der Inhalt dieses Beispiels ist jetzt noch nicht von Bedeutung, wird aber im übernächsten Kapitel ausführlich beschrieben. Zuvor müssen wir uns noch mit dem Compiler befassen. 1) Linux-KDE : Die Linux-KDE ist eine graphische Oberfläche, so ähnlich wie Windows. Es gibt also auch Fenster und Multitasking ist möglich. 2) Linux-Konsole : Die Linux-Konsole stellt das Gegenstück zu MS-DOS dar, weshalb nur ein Programm gleichzeitig laufen kann, was dem Programmierer eine Menge Arbeit spart, aber für den Benutzer nicht sehr komfortabel ist. ---------------------------------------- Der Compiler Ein C++-Programm kann von einem Programmierer in jedem beliebigen Texteditor geschrieben werden. Unter Windows könnte man z.B. Notepad verwenden. Bloß diese Textdatei muss erst noch in einen dem Computer verständliche Sprache übersetzt werden. Diesen Vorgang nennt man kompilieren und weil das auf Englisch to compile heißt, nennt man das Programm, das die Übersetzungsarbeit macht, Compiler. Aber woher bekomme ich einen solchen Compiler? Nun, die meisten C/C++-Compiler sind kostenlos im Internet zu downloaden. Wer Linux verwendet hat es ein bisschen einfacher, da die meisten Linux-Distributionen einen C++-Compiler bereits mitliefern. Wer allerdings Linux und Windows parallel laufen hat, kann ein Programm nur in dem Betriebssystem laufen lassen, wo er es kompiliert hat. Der wohl berühmteste C++-Compiler dürfte wohl der GNU-Compiler sein. Für Windows gibt es entweder http://www.borland.com/ oder unter http://www.delorie.com/djgpp einen Compiler zur Auswahl. Die Files (max. 20MB) dürften 20 - 40 Minuten dauern, was sich echt lohnt. Wer MS Visual C++ hat kann dieses natürlich auch verwenden, sollte aber ein neues Programm immer mit Datei/Neu und dann eine Konsolenanwendung auswählen, weil sonst MS Visual C++ davon ausgeht, das sie ein Windowsprogramm schreiben wollen. So jetzt ist es aber an der Zeit, dass ich dir zeige wie du ein Programm schreibst und übersetzt. -------------------- 1) DOS mit DJGPP: Nennen wir das unterstehende Programm einfach mal Beispiel01. Um dieses Programm zu erzeugen öffnest du einen Texteditor (unter DOS mit EDIT ) und schreibe zunächst den unterstehenden Text ab, wobei du auf Groß- und Kleinschreibung achten musst: #include void main() { cout << "Hallo, ich bin dein erstes Beispielprogramm\n"; } Dann speicherst du das ganze unter dem Namen beispiel01.cpp ab. Wenn DJGPP richtig installiert ist musst du nur noch den Texteditor verlassen und gxx -o beispiel01.exe beispiel.cpp in die Kommandozeile eingeben. Wenn keine Fehlermeldung kommt kannst du das Programm mit beispiel01.exe starten. Nun sollte folgendes auf dem Bildschirm erscheinen: Hallo,ich bin dein erstes Beispielprogramm -------------------- 2) Linuxkonsole mit g++ : Nennen wir das untenstehende Programm einfach mal Beispiel01. Um dieses Programm zu erzeugen öffnest du einen Texteditor (unter Linux z.B.mit Joe ) und schreibe zunächst den untenstehenden Text ab, wobei du auf Groß- und Kleinschreibung achten musst: #include void main() { cout << "Hallo, ich bin dein erstes Beispielprogramm\n"; } Dann speicherst du das ganze unter dem Namen beispiel01.cpp ab. Wenn g++ installiert ist musst du nur noch den Texteditor verlassen und gxx -o beispiel01 beispiel.cpp in die Kommandozeile eingeben. Wenn keine Fehlermeldung kommt kannst du das Programm mit ./beispiel01 starten( ./ weil Linux Programme nicht im aktuellen Verzeichnis sucht). Nun sollte folgendes auf dem Bildschirm erscheinen: Hallo,ich bin dein erstes Beispielprogramm -------------------- 3) Windows mit MS Visual C++ : Mit "Datei/Neu" kommst du in das Auswahlfenster für die verschieden Programmarten. Dort wählst du "Win32-Konsolenanwendung" aus und trägst in dem Feld Projektname beispiel01 ein. Nachdem du auf "OK" geklickt hast, wählst du im nächsten Fenster eine leere Anwendung aus und klickst auf "Fertigstellen". Jetzt musst du noch mal auf "Datei/Neu" wo du nun eine "C++-Quellcodedatei" auswählst, die du beispiel01.cpp nennst. In diese Datei kannst du den folgenden Text schreiben: #include void main() { cout << "Hallo, ich bin dein erstes Beispielprogramm\n"; } Mit einem Klick auf die Disketten kannst du alles speichern. Jetzt wähle im Menü "Erstellen/beispiel01.exe erstellen" aus. Nun solltest du im unteren Fenster sehen wie kompiliert wird. Am Ende sollte "beispiel01.exe - 0 Fehler, 0 Warnung(en)" stehen, sonst hast du höchstwahrscheinlich einen Fehler gemacht. Wenn du jetzt auf Erstellen/Ausführen von beispiel01.exe" klickst, wird sich ein DOS-Fenster öffnen in dem folgendes steht: Hallo, ich bin dein erstes Beispielprogramm Press any key to continue Das im Gegensatz zu den anderen Compilern noch eine Zeile dasteht braucht dich nicht zu beunruhigen, weil es nichts mit dem Compiler sondern mit dem DOS-Fenster zu tun hat. Du kannst natürlich das kompilieren und Ausführen des Programms auch mit den Shortcuts machen( F7 und Strg + F5). -------------------- 4)Jeder andere C++-Compiler: Schau einfach in der Anleitung zu dem Compiler nach, wie er zu bedienen ist. Meistens funktionieren sie so ähnlich, wie DJGPP oder g++ Da du jetzt gelernt hast wie dein Compiler funktioniert , weist du auch wie du die nächsten Beispiele kompilieren kannst. Solltest du mit deinem Compiler absolut nicht zurechtkommen, kannst du auch einfach auf einen anderen umsteigen oder mir eine eMail schreiben vielleicht kann ich dir ja weiter helfen. -> email ---------------------------------------- Grundlagen Nun willst du aber sicher wissen was die einzelnen Ausdrücke bedeuten. Hier ist nochmal das ganze Programm : #include void main() { cout << "Hallo, ich bin dein erstes Beispielprogramm\n"; } Fangen wir am besten mit void main() an. void main signalisiert das hier eine Funktion beginnt. Nun wirst du dich sicher fragen, was eine Funktion ist. Das ist hier aber noch nicht wichtig und wird erst viel später erklärt. Zu dem void main() gehören auch noch die zwei Geschweiften Klammern. Alles was zwischen den beiden Klammern steht wird am Programmstart aufgerufen. In diesem Fall ist das nicht sehr viel, aber in späteren Programmen wird es sehr umfangreich. void main() muss bei jedem Programm vorhanden sein, welches im Textmodus arbeitet, also in MS-DOS's oder in der Linux-Konsole. Bei mehr als einer Zeile werden immer von oben nach unten die Anweisungen ausgeführt. Unsere Anweisung lautet cout << "Hallo, ich bin dein erstes Beispielprogramm\n"; und besteht im wesentlichen aus vier Teilen. Der erste ist das cout was den Ausgabestrom auf den Bildschirm darstellt. Mittels des Operators << wird er Operant "Hallo, ich bin dein erstes Beispielprogramm\n" in den Ausgabestrom geleitet. Schließlich folgt noch der Terminator ; der das Ende der Anweisung anzeigt. Die Anweisung #include ganz oben sorgt dafür, dass cout überhaupt verwendet werden kann. Alle Anweisungen die mit einem # beginnen, werden vor dem eigentlichen kompilieren vom Präcompiler durch den Inhalt der jeweiligen Include-Datei ersetzt. In unserem Fall wird mit der Präcompiler Anweisung #include die Include-Datei iostream.h an dieser Stelle eingefügt. Die beiden < und > zeigen, dass sich die Include-Dateien im Include-Verzeichnis des Compilers befinden. Würden sich die Datei in c:\Daten\Programm befinden müsste man #include "iostream.h" schreiben. Include-Dateien erkennt man an der Endung .h (neuerdings auch .hpp). Wenn du willst kannst du die Datei auch anschauen, da sie nicht Binär, sondern als Textdatei gespeichert ist. Du kannst auch selbst Include-Dateien schreiben, was jetzt allerdings noch etwas früh ist. Weiteres über den Präcompiler findet ihr später. Um die Bedeutung von \n am Ende des Textes zu erkennen, wollen wir jetzt erst mal das Programm erweitern. Und zwar so: #include void main() { cout << "Hallo, ich bin dein erstes Beispielprogramm"; cout << "2.Zeile" } Was passiert jetzt? Wieso wird der Text in einer Zeile dargestellt? Das liegt daran, dass wir das \n weggelassen haben. Es ist eine sogenannte Escape-Zeichenfolge. Hier ist eine Liste mit den meisten Escape-Zeichenfolgen,dem jeweiligen Ascii-Code und ihrer Bedeutung: Zeichen ' " \ Nullzeichen(NULL) Signalton(BEL) Rückschritt(BS) Horizontaler Tabulator(HT) Zeilenvorschub(NL/LF) Vertikaler Tabulator(VT) Seitenvorschub(FF) Wagenrücklauf(CR) Oktale Zahl Hexadezimale Zahl ASCII-Code 39 34 92 0 7 8 9 10 11 12 13 Escape-Sequenz \' \" \\ \0 \a \b \t \n \v \f \r \ooo \xhhh Jetzt könntest du z.B. am Ende der Ausgabe einen Signalton ertönen lassen. Es gibt noch eine weitere Besonderheit von cout. Du kannst nämlich beliebig viele << Operatoren und entsprechende Operanden hintereinander hängen, wie in folgendem Beispiel: #include void main() { cout << " 1.Ausgabe" << " 2.Ausgabe" << " 3.Ausgabe"; } Dieses Programm würde folgende Ausgabe erzeugen: 1.Ausgabe 2.Ausgabe 3.Ausgabe Als letztes möchte ich in diesem Kapitel noch die Kommentare vorstellen. Möchte man z.B. sagen für was man eine Include-Datei hinzufügt, braucht man eine Möglichkeit Text zu verfassen, der vom Compiler ignoriert wird. Dies geschieht entweder mit // oder mit /* */. // lässt den Compiler den Text bis zum Ende der Zeile ignorieren. Mit /* beginnt man einen Kommentar, der erst beim nächsten */ oder am Ende der Datei endet: #include //für cout void main() //Der Anfang von Main. { /*Hier befinden wir uns in der Funktion Main. Die sehr interessant ist*/ cout << "Hallo, ich bin dein erstes Beispielprogramm"; cout << "2.Zeile" } //Das Ende von Main. Mit Kommentaren kann man schnell Code ungültig machen ohne ihn zu löschen, was bei Fehlern oft hilft. Im nächsten Kapitel geht es um Variablentypen und Konstanten, was den reizt einer Anwendung ausmacht. ---------------------------------------- Variablen Das im letzten Kapitel beschriebene Programm ist trotz all seiner Variationen nicht sehr interessant. Den richtigen Reiz einer Anwendung macht es aus, wenn der Benutzer eingaben machen kann und diese dann für Berechnungen hergenommen werden können. Dafür müssen die Angaben in sogenannten Variablen zwischengespeichert werden. Der Platz, den die Variablen im Speicher benötigen, muss grundsätzlich einmal vor dem eigentlichen Programmstart ,bereitgestellt werden. Wir werden später allerdings noch Ausnahmen kennen lernen, jetzt aber erst mal den regulären weg gehen. Als erstes müssen wir uns auf einen Datentyp einigen, weil davon abhängt, wie viel Speicher reserviert werden muss. Hier sind erst mal die gewöhnlichsten Datentypen aufgelistet: ############################## 1) Name (ohne Kommastellen) ## 2) Größe ## 3) Wertebereich ## 4) Beispiel-Code ## ############################## char ## 1 Byte ## -128 bis 127 ## char test1; ## ## unsigned char # 1 Byte # 0 bis 255 # unsigned char test2; # short 2 Byte -32768 bis 32767 short test01; unsigned short 2 Byte 0 bis 65535 unsigned short test04; integer 4 Byte -2147483648 bis 2147483647 int test05; unsigned Integer 4 Byte 0 bis 4294967295 unsigned int test06; long 4 Byte -2147483648 bis 2147483647 long test05; unsigned Long 4 Byte 0 bis 4294967295 unsigned long test06; Name (mit Kommastellen) Größe Wertebereich Beispiel-Code float 4 Byte 3.4 * 10-38 bis 3.4 * 1038 float test07; double 8 Byte # 1.7 * 10-308 bis 1.7 * 10308 # double test08; # # long double ## 10 Byte ## 1.2 * 10-4932 bis 1.2 * 104932 ## long double test09; ## ################################# Was der Unterschied zwischen integer und long ist weis ich nicht da sie bei mir immer 4 Byte groß sind. Ich glaube aber, dass sie früher einmal unterschiedlich groß waren. Das unsigned bedeutet, dass die Variable ohne Vorzeichen steht, also immer positiv ist. Grundsätzlich kann man sich den Wert von Variablen mit cout << Variablenname ausgeben lassen. Schreiben wir also ein kleines Beispielprogramm: #include void main() { int i; cout << "Der Wert der Variable i: " << i; } Dann erhalten wir eine Ausgabe ähnlich der folgenden: Der Wert der Variable i: -1548719 Woran liegt das? Da wir zwar einen Speicherplatz für die Variable i beantragt haben, aber ihr noch keinen Wert zugewiesen haben, enthält sie einen mehr oder weniger zufälligen Wert. Dieser Speicherblock ist früher von anderen Programmen genutzt worden, die ihn zwar wieder freigegeben haben, aber dessen Inhalt nicht gelöscht haben. Wir müssen der Variable also erst einen Wert zuweisen. Das geschieht mit Variablenname = Wert in dem folgenden Programm: #include void main() { int i; i=100; cout << "Der Wert der Variable i: " << i; } Nun erhalten wir folgende Ausgabe: Der Wert der Variable i: 100; Man kann die Zuweisung auch gleich in die Variablendeklaration einbinden, weshalb das nächst Programm das gleich tut wie das letzte: #include void main() { int i=100; cout << "Der Wert der Variable i: " << i; } Das besondere an Variable ist das sie beliebig oft verändert werden können, wie in dem nächsten Beispiel: #include void main() { int i; i=50; i=1000; i=-20; cout << "Der Wert der Variable i: " << i; } Dieses Programm führt zu der Ausgabe: Der Wert der Variable i: -20 Im Gegensatz dazu stehen Konstanten, die nur einmal zu Beginn des Programms festgelegt werden müssen und danach nicht mehr verändert werden können. Sie werden mit const Datentyp Konstantennname = Wert deklariert, wobei für Datentyp alle Datentypen die auch für Variablen gültig sind möglich sind. Spätere Änderungen des Wertes mit Konstantennname = Wert sind nicht zulässig und rufen einen Fehler des Compilers hervor. Es können auch mehrere Konstanten und Variablen auf einmal deklariert werden: #include void main() { int a=1,b=2,c=3,d=4; const int x=5,y=10,z=15; cout << "Variablen: " << a << b << c << d<< "\n"; cout << "Konstanten: " << x << y << z; } Was folgende Ausgabe ergibt: Variablen: 1234 Konstanten: 51015 Variablen und Konstanten können einer Variable zugewiesen werden: #include void main() { int a=1,b=2; const int x=5; a = b; b = x; cout << "Variablen: " << a <<" " << b << "\n"; cout << "Konstanten: " << x; } Dieses Programm gibt folgendes aus: Variablen: 2 5 Konstanten: 5 Im nächsten Kapitel geht es dann um Operatoren, wodurch Variablen erst richtig interessant werden. Einen Operator haben wir ja bereits kennen gelernt. ---------------------------------------- Operatoren In diesem Kapitel geht es um Operatoren, die zusammen mit der Ausgabe und Variablen am häufigsten in Programmen auftauchen. Die berühmtesten Operatoren sind die Grundrechenarten, aber auch Vergleichsoperatoren, wie z.B. < . Bevor ich aber die einzelnen Operatoren vorstelle, möchte ich noch etwas Grundsätzliches zu Operatoren sagen. Der Computer kann immer nur eine Rechnung auf einmal durchführen. Wäre die Aufgabe beispielsweise 5 + 10 +100 , so geht der Computer eigentlich genauso vor wie wir, bloß sehr strickt. Er fängt dabei immer von Rechts an. Als erstes werden 10 und 100 addiert und dessen Ergebnis zwischengespeichert und dann zu dem Zwischengespeicherten 5 hinzuaddiert. Bei dieser Aufgabe ist die Reihenfolge egal, aber bei schwierigeren Aufgaben spielt sie durchaus eine Rollen. Aber bei der folgenden Aufgabe gäbe es ein Problem wenn er immer so vorgehen würde: 20 * 10 + 1 ( Der Stern steht für MAL) Bei dieser Aufgabe sagt jeder, dass 201 rauskommt, aber der Computer würde nach der obigen Regel 20 * 11 = 220 rechnen. Das tut er aber nicht , den jeder Operator hat eine bestimmt Priorität. In der folgenden Tabelle kann man ablesen, das * eine höhere Priorität als + hat und der Computer also 20 * 10 = 200 und 200 + 1 = 201 rechnet. Es ist also durchaus möglich, mehrere Operatoren in eine Zeile zu schreiben, wie z.B. 20 * 15 + 10 * 30 * 5 / 3 + 4. Deshalb kann man auch cout << 5 + 1 schreiben. Die folgende Tabelle listet die in C++ üblichen Operatoren mit ihrer Priorität auf: ############################## 1) Priorität ## 2) Operator ## 3) Bedeutung ## 4) Beispiel-Code ## ############################## ## 17 ## :: # Bereichszugriff (unär) # Klasse::Funktionsname 17 :: Bereichszugriff (binär) Klasse::Funktionsname 16 ( ) Funktionsklammern Funktionsname(Parameter) 16 ( ) Objektkonstruktion Klasse(Parameter) 16 [ ] Array-Index a[3]= 5; 16 . oder -> Komponentenauswahl Klasse.x oder zeiger->x 15 ( ) Typkonvertierung (cast) var1 = (int) var2; 15 sizeof Größe von Variablen sizeof(int); 15 & Adress-Ermittlung &var1; 15 * Verweis/Indirektion pointer = *var1; 15 ~ Bitweise Negation var1 = ~var1; 15 ! Logische Negation boole1 = !boole2; 15 + - Plus, Minus (unär) a = -b; 15 ++ -- Inkrement,Dekrement a++; 15 new, delete Dynamische Variablen zeiger = new int; 14 .* Komponentenauswahl Klasse.*pointer 14 ->* Komponentenauswahl pointer1->*pointer2 13 * Multiplikation a = b * c; 13 / % Division, Modulo a = b / c; oder a = b % c; 12 + - Plus, Minus (binär) a = a + b; oder a = b - c; 11 << >> Bitverschiebung a = < <= >= größer, kleiner a < b 9 == != vergleich a == b oder a != b 8 & Bitweises UND a & 5 7 ^ Bitweises ODER (exklusiv) a ^ b 6 | Bitweises ODER (inklusiv) a | b 5 && Logisches UND a && b 4 || Logisches ODER a || b 3 ? : Bedingung a < 0 ? b = 1 : b = 2; 2 = Zuweisung a = b; 2 + = -= Zuweisung a += b;ist wie a = a + b 2 *= /= %= Zuweisung a /= b;ist wie a = a / b 2 <<= >>= Zuweisung a <<= b;ist wie a = << b 2 &= ^= |= Zuweisung a |= b;ist wie a = a | b 1 , Sequenz int a, b; ---------------------------------------- Der Cast-Operator Mit diesem Operator können Datentypen explizit ineinander konvertiert werden. In die Klammern schreibt man einfach den Datentyp den man gerne hätte. Die Typumwandlung ist nur selten erforderlich, da bei den meisten Typen die Konvertierung automatisch bei einer Zuweisung erfolgt. #include void main() { double i = 50.7; int a; a = (int) i; cout << "Der Wert von a: " << a << "\n"; } Bei diesem Beispiel wird die Nachkommastelle von i abgeschnitten (nicht gerundet), weil der Ziel Datentyp nur ganze Zahlen zulässt. Die Konvertierung geht natürlich mit jedem Datentyp sogar mit selbst definierten (siehe dazu das Kapitel Eigene Datentypen). ---------------------------------------- Der Sizeof-Operator Mit diesem Operator kann die Größe von Datentypen (nicht deren Wert) ermittelt werden, was bei Arrays und Klassen interessant wird. Sizeof liefert die Größe in Bytes. Die Syntax lautet: sizeof(Datentyp). Dazu wieder ein Beispiel: #include void main() { double i = 50.7; int a = 20; cout << "Die Größe von i: " << sizeof(i) << " Bytes\n"; cout << "Die Größe von a: " << sizeof(a) << " Bytes\n"; } Bei diesem Beispiel sollte diese Ausgabe entstehen (Es kann zu einer falschen Darstellung von den Umlauten kommen): Die Größe von i: 8 Bytes Die Größe von a: 4 Bytes ---------------------------------------- Der Adress-Operator Die Adresse einer Variable wird mit einem & vor dem Variablennamen ermittelt. Die Adresse ist eine hexadezimale Zahl (weshalb wir sie zuerst in eine dezimale Zahl umwandeln), die den Speicherblock angibt, bei der die Variable anfängt. Bis jetzt können wir uns diesen Wert nur sagen lassen, aber noch nichts sinnvolles damit tun: #include void main() { double i = 50.7; int a = 20; cout << "Die Position im Speicher von i: " << (int)&i << "\n"; cout << "Die Position im Speicher von a: " << (int)&a << "\n"; } Es sollte eine Ausgabe wie die folgende sein, aber bei jedem Programmstart werden andere Speicherzellen mit anderen Nummern verwendet, weshalb die Zahlen jedes Mal anders seien können und von denen hier abweichen: Die Position im Speicher von i: 674923 Die Position im Speicher von a: 671456 ---------------------------------------- Die logischen Operator Die logischen Operatoren kommen hauptsächlich in Bedingungen vor (Was eine Bedingung ist wird im übernächsten Abschnitt erklärt). Die Operanden und das Ergebnis eines logischen Operators ist immer ein boolsche Wert. Was heißt boolsch eigentlich? Die Idee hinter der ganzen Sache ist, das es zwei Zustände gibt. Nämlich true und false. Es gibt noch viele andere Ausdrucksweisen. Z.B kann man für false auch falsch, 0 oder nein sagen. Genauso gibt es für true die Möglichkeiten wahr, 1 oder ja zu sagen. Zurück zu den Operatoren. Es gibt drei logische Operatoren in C++ : ! , && und || . Als erstes das !, welches für not steht und den Operanden hinter ihm negiert. So kann man z.B. !false (oder auch !0)schreiben, was denn wert true ergibt. Anders herum entspricht natürlich !true (oder auch!1) false. Als Ausgabe erhält man allerdings denn Zahlenwert ( 0 , 1 ) und nicht die Zeichenfolge. Dies ist eigentlich der einfachste Operator, weil es nicht mehr als diese beiden Möglichkeiten gibt. Ich möchte aber noch eine kleine Besonderheit von C++ erklären, die für alle logischen Operatoren gilt. In C++ werden nämlich alle Zahlen die nicht 0 sind als true angesehen. So kann man nicht nur !1 sondern auch !12345 schreiben. Bei && wird es schwieriger. Dieser Operator hat zwei Operanden und das Ergebnis ist nur dann true, wenn beide Operanden true sind. Genau andersherum ist es bei ||, wo immer true herauskommt, außer beide sind false. Hier ist eine Kleine Tabelle über die Möglichkeiten: ! && || true&&true true true||true true ! true false true&&false false true||false true ! false true false&&true false false||true true false&&false false false||false false Zum Schluss noch ein Beispiel zu den logischen Operatoren: #include void main() { double i = 10; int a = 20; int wert1 = i && a; int wert2 = !a; int wert3 = !a && i && !a; cout << wert1 << wert2 << wert3; cout << "\nVieleicht fallen dir mehr Ideen ein als mir.\n"; } ---------------------------------------- Bitweise Operator Bit? Nein, diese Operatoren haben nichts mit Bier zu tun. Ein Bit ist die kleinste Einheit bei einem Computer, wie du sicher schon weist. Um zu verstehen wie die Bitweisen Operatoren funktionieren, muss man wissen, wie der Computer Daten speichert. Wie speichert er z.B. die Zahl 13? Sie wird grundsätzlich erst mal gesagt Binär gespeichert. Binär? Ja, binär ist ein Zahlensystem dessen zwei Ziffern 0 und 1 sind. Am besten ich erkläre dieses an einer Tabelle. Sie entschlüsselt die Zahl 13 in binärer Schreibweise: 0 0 0 0 1 1 0 1 0 x 128 0 x 64 0 x 32 0 x 16 1 x 8 1 x 4 0 x 2 1 x 1 Um diese Binäre Zahl in das Dezimalsystem um zurechnen muss man einfach nur entschlüsseln, welche 1 für welche Dezimalzahl steht: 1 x 1 = 1 0 x 2 = 0 1 x 4 = 4 1 x 8 = 8 0 x 16 = 0 0 x 32 = 0 ... es folgen nur Nuller Daraus folgt: 1 + 0 + 4 + 8 + 0 + 0 + 0 + 0 + 0 ... nur Nuller = 13 ! && || true&&true true true||true true ! true false true&&false false true||false true ! false true false&&true false false||true true false&&false false false||false false ------------------------------------------- Zum Schluss noch ein Beispiel zu den Operatoren: #include void main() { double i = 10; int a = 20; int wert1 = i && a; int wert2 = !a; int wert3 = !a && i && !a; cout << wert1 << wert2 << wert3; cout << "\nVieleicht fallen dir mehr Ideen ein als mir.\n"; } ----------------------------------------- Text von: Richard Schaller Übersetzung in das text-Format: c-schell www.c-schell.de