So, mal das Gröbste, was mir beim Überfliegen auffällt:
DEFAULT DATATYPES
Heißen im Standard "integral types".
Größe in Bytes ist nicht definiert, außer für char - der muss ein Byte sein. Alle anderen Integer-Typen müssen größer sein und sind geordnet (char <= short <= int <= long int) usw. Die Größen passen aber auf üblichen Systemen. Vielleicht kann man ja sowas wie "usual size in bytes" dazu schreiben. bool kann übrigens auch gerne mal 4 Bytes haben.
wchar_t fehlt noch.
void hat keine Größe, auch nicht 0 Bytes. void ist ein unvollständiger Typ, der niemals ein vollständiger Typ sein kann.
INLINE TYPE SPECIFICATION
2LL - C++ 98 (mit 2003 Amandements) kennt kein long long, auch wenn viele Compiler es trotzdem fressen. g++ -pedantic-errors sollte meckern. Wie's mit dem neuen Standard aussieht, weiß ich gerade nicht, aber ich vermute, dass long long dann kein Problem mehr ist.
2.0f //
f has no effect, float
nicht richtig - das definiert 2 als Float-Literal. Bsp:
Code:
void foo( float f);
void foo( double f);
void bar()
{
foo( 2.0); // calls void foo( double f);
foo( 2.0f); // void foo( float f);
}
VARIABLE/FIELD DECLARATION
Finde ich verwirrend, Benamung ist ungenau.
[storage-class-specifier] [cv-qualifier] [type]
cv-qualifier: [none], const, volatile, const volatile
storage-class-specifier: auto, register, static, extern, mutable
DECLARATION FLAGS
volatile: was volatile macht, ist im Standard unzureichend spezifiziert. Auf jeden Fall nicht (zwingend) das von dir beschriebene. Ist i.d.r. ein Hinweis, hier nicht zu optimieren.
register: ist ein Hinweis, dass dieses Objekt häufig benutzt wird. Ist aber nur ein Hinweis und nicht mehr als das - wird meistens ignoriert, spätestens wenn man die Adresse von dem Objekt nimmt
static: "The storage for these objects shall last for the duration of the program" (ausm Standard)
Find ich bis hierhin nicht so richtig gut, bzw. ungenau/unvollständig, je nach Anspruch des Lesenden. Allerdings würde die vollständige und genaue Variante bei weitem den Rahmen sprengen.
INITIALIZATION
int a, b = 5; //a =
pseudo-random, b = 5
a ist "undefined".
TYPE CASTING
new_type expr2 = (new_type) expr1; // C-style cast
new_type expr2 = new_type (expr1); // can be Function-style cast or constructor + assignment operator call
a = float(7/2); /*a=3.5*/
Ohne gerade einen Compiler zur Hand zu haben, würde ich behaupten, dass das 3 ergibt.
static_cast, dynamic_cast, const_cast, reinterpret_cast fehlen.
C-style casts sind i.A. discouraged.
BASIC PROGRAM STRUCTURE
Es gibt kein iostream.h. Stammt aus Zeiten vor C++98 und so ziemlich kein Compiler bringt diesen Header mit.
OPERATOR PRECEDENCE & ASSOCIATIVITY
Wo ist * als dereference? Unary oder binary könnte hilfreich sein.
There are more
commands like +=
operators
INCREMENT & DECREMENT OPERATOR
Irgendwas von prefix und postfix wäre evtl. hilfreich.
DYNAMIC MEMORY (NEW, DELETE)
int* c = new int (6); int* d = new int(3)[3]; //
*c=6, d:error
REFERENCES
int &a; //error:
refs are never null
refs require initialization
POINTER-ARITHMETICS
p = b; //assigns b‟s address to p
Ungenau. Führt die implizite array-to-pointer Conversion durch und weist den Wert p zu.
b = p; //error: b is const
b ist nicht const.
b[5] = 0; // b [offset of 5] = 0
Als Gag könnte man noch 5
= 0; aufnehmen. Ist das gleiche. 
FUNCTIONS / METHODS
<pedantisch>C++ kennt keine Methoden. Das Wort kommt nicht im Standard vor. Heißen member functions</pedantsch>
Willst du friend mit aufnehmen? Macht das Beschreiben aber ziemlich frickelig.
const(2nd) - hier geht auch volatile und const volatile.
ARGUMENTS
call by reference (pointer)
Ist allerhöchstens ein impliziter call by reference. Ein Pointer wird per value übergeben.
OVERLOADING
They have to have different footprints[/color=, so that the compiler (and you) know which one to take.
signature. Wobei ich erst exakt nachschlagen müsste, wie es korrekt heißt - auf jeden Fall nicht footprint. have to have klingt auch nach schlechtem Englisch - need to have wäre zumindest besser.
UNIONS
Ein Hinweis darf nicht fehlen, dass nur das Element gelesen werden darf, das zuletzt geschrieben wurde. Alles andere ist undefiniertes Verhalten.
EXCEPTIONS
inherit from std::exception
void foo() throw(); //cannot throw
will not throw ist besser. Wird trotzdem geworfen, wird std::terminate() aufgerufen.
catchen per const & wäre hübscher. throw by value, catch by const reference.
TYPEDEF
//now you can use bigint instead of int
long
CLASSES
In-class init is not permitted for non-static and non-const
verstehe ich nicht.
Ansonsten redundant zu struct.
CONSTRUCTOR
//construct b first, then a
Falsch. Die Reihenfolge in der Initialisierungsliste ist irrelevant.
There is a default constructor doing nothing, if not specified
Falsch. Für jeden Member wird der Default-Constructor aufgerufen. Der Default-Konstruktor wird nur synthetisiert, wenn es keinen anderen gibt.
Im Falle deiner Deklaration class C { C (int); }; würde keiner synthetisiert.
Implicit type cast: C foo = 4;
Ruf einen conversion constructor auf, falls vorhanden.
Implicit init: C foo(4);
Nennt sich "direct initialization". "Implicit init" finde ich mindestens misleading.
Explicit init: C foo = C(4);
Nennt sich "copy initialization". Ebenfalls misleading. Hier wird übrigens in keinem Fall ein Zuweisungsoperator aufgerufen.
The keyword explicit inhibits copy initialization.
Implicit init not allowed for constructor without args:
A foo(); /*error*/ A foo; A bar = A(); //ok
misleading. A foo() deklariert eine Funktion namens foo ohne Parameter mit Rückgabetyp A.
A foo(); /*error: function declaration*/ A foo; A bar = A(); //ok
COPY-CONSTRUCTOR
If not specified: bit by bit copy.
Falsch. Für jeden Member wird der Zuweisungsoperator aufgerufen.
class A { A(A & copyFromMe) { … } … };
Referenz ist nicht notwendig. Und wenn, dann i.a.R. eine const-Referenz, da das Objekt, von dem Kopiert wird, nicht verändert werden sollte. (principle of least surprise)
STATIC & CONST VARIABLES
static variables’ memory is not freed
doch, am Programmende. Inklusive Destruktor-Aufruf.
INHERITANCE
friend-methods can never be inherited
Besser: friendship does not inherit.
Die Beschreibungen finde ich misleading. Am besten weg mit dem Beispiel bei public.
DYNAMIC BINDING
Das Wort static hat dort nichts verloren. Das far more performant ist ist falsch. "a tiny, tiny, tiny bit more performant" wäre wesentlich realitätsnäher. Ab besten garnicht erwähnen.
OVERRIDING OPERATORS & TYPE CASTS
operator int(){ return 4;} //typecast
ist kein cast. Definiert einen user defined conversion operator.
int main(){int i = 2; return i.operator+(1);} //ok
äääh.....?
NAMESPACES
evtl. using-Direktiven und using-Deklarationen unterscheiden?
POLYMORPHISM
C-style casts haben bei Klassen (und eigentlich in jedem guten C++-Programm) nichts verloren. Viele, viele, viele gemeine Fallstricke. Ist der Typ z.B. unvollständig, wird der Zeiger einfach vergewaltigt.
extern void f(L*); //some standard function
TEMPLATES
finde ich gefährlich, soooo kurz abzuhandeln.
<IOSTREAM> - INPUT & OUTPUT STREAMS
cout << “foo”; //console out
write to stdout
cerr << “foo”; //console error
write to stderr with flushing after each operation
clog << “foo”; //console log
write to stderr without flushing after each operation
<CCTYPE> - CHARACTER FUNCTIONS
char toupper(char);
Nope, das ist int toupper( int).
Übergeben werden darf ein unsigned char oder EOF.
POSSIBLE MISTAKES / CHECKLIST
Arrays with non-const size
kann ich mir nix drunter vorstellen.
There is no ‘null’ in C/C++
Was meinst du damit?
Korrigiert. Werde etwas später die neue Version raufladen.
