Voici un index de tous les mots clés, les instructions et les notions et définitions vus dans les cours.

Instructions:

cin		int valeur; cin >> valeur; Permet la saisie au clavier de valeurs de types fondamentaux. Défini dans iostream.h.
cos		double cos(double arg); Renvoie le cosinus de l'angle arg exprimé en radians. Défini dans math.h.
cout		int valeur = 10; cout << "Valeur vaut : " << valeur << endl; Permet l'affichage à l'écran messages et de valeurs de types fondamentaux. "endl" permet le retour à la ligne. Défini dans iostream.h.
get		istream& istream::get(char* buffer, int len, char delim = '\n'); La fonction cin.get() permet de récupérer dans un buffer une chaîne de longueur maximale len saisie au clavier. Le caractère delim sert à indiquer la fin de la chaîne (par défaut, il s'agit du caractère de fin de ligne). Défini dans istream.h (lui-même inclut dans iostream.h)
sin		double sin(double arg); Renvoie le sinus de l'angle arg exprimé en radians. Défini dans math.h.
sqrt		double sqrt(double x); Renvoie la racine carrée de x. x doit être supérieur ou égal à 0. Défini dans math.h.
sync		int istream::sync(); Utilisé avec cin (cin.sync()), cette fonction vide le tampon d'entrée de cin. Défini dans istream.h (lui-même inclut dans iostream.h)
tan		double tan(double arg); Renvoie la tangente de l'angle arg exprimé en radians. arg doit être différent de pi/2 ou -pi/2 (modulo 2*pi bien sûr). Défini dans math.h.

Mots clés:

break		Sort directement d'un bloc switch. Sort directement d'une boucle for, while ou do...while.
const		Lors d'une déclaration de variable, précise au compilateur que cette variable ne changera pas de valeur lors de l'exécution du programme. Il devient alors impossible de lui affecter de nouvelle valeur après la déclaration. Il faut donc l'initialiser en même temps que la déclaration. const int x = 10; Voir Les structures de sélection : un peu plus loin.
continue		for(int i = 0; i <= 9; i++) { if(i%2 == 0) continue; cout << "i est impair!\n"; } S'utilise dans une boucle (for, while ou do...while) pour passer directement à l'itération suivante. Voir Les boucles : de 1 à 10
do...while		do { instructions; } while(condition); Exécute instructions et recommence si condition est vraie. La seule différence avec la boucle while est que instructions est exécuté au moins une fois. Les instructions break et continue permettent d'agir sur le déroulement de l'exécution. Voir Les boucles : jusqu'au stop !
enum		enum NomDeType { constante1 = valeur1, constante2 = valeur2, constante3... } nomDeVariable; Une énumération permet d'isoler un certain type de valeurs précises (comme les 12 mois de l'année par exemple, ou les jours de la semaine, ou des niveaux d'alerte dans un système) afin de créer un ensemble de valeurs cohérent. Les constantes prennent les valeurs indiquées par l'affectation ou, si aucune valeur n'est précisée, elles prennent la valeur de la constante précédente augmentée de 1. La première valeur par défaut est 0. Voir Structures, unions et énumérations de données
for		for(initialisation ; condition ; incrémentation) instructions; Exécute instructions jusqu'à ce que l'expression logique condition soit fausse. Un compteur peut être initialisé avec initialisation, et son évolution peut être déterminée par incrémentation. initialisation est exécuté avant le début de la boucle. Chaque passage est précédé par une évalutation de condition, et est terminé par l'exécution de incrémentation. L'instruction break permet de sortir immédiatement de la boucle. continue permet de passer à l'itération suivante. Voir : Les boucles : de 1 à 10
if... else....		if(condition) instruction; ou alors if(condition) instruction1; else instruction2; Permet d'exécuter une instruction ou un bloc d'instructions suivant la valeur de vérité d'une expression logique (dans ce cas, il s'agit de condition). L'instruction qui est ratachée au if est exécutée si la valeur de condition est vraie. S'il y a un else, l'instruction qui lui est ratachée est exécutée si la valeur de condition est fausse. Voir Les structures de sélection : première approche.
new delete		int* p = new int; delete p; int* p = new int(3): delete p; int* p = new int[10]; delete[] p; new permet de créer un objet sur le tas, et renvoie un pointeur vers cet objet. delete va détruire cet objet. Voir La gestion dynamique de la mémoire
return		int fonction(void) { return valeur; } Arrête l'exécution de la fonction et renvoie (si précisé) valeur à la fonction appelante. Une fonction du type void ne peut pas renvoyer de valeur (l'instruction return s'utilise alors seule).
sizeof		double a = 0; cout << sizeof(a) << endl; sizeof renvoie la taille en octets de la variable spécifiée en paramètre.
static		A l'intérieur d'une fonction, une variable déclarée satic (static int x = 0) garde sa valeur lorsque la fonction se termine et la retrouve lorsque la fonction est rapelée. Elle n'est donc déclarée qu'une fois pour toutes, et n'est jamais détruite. Une variable déclarée static de cette manière doit être initialisée dans la déclaration. Un variable membre déclarée static dans une struct/class est partagée par toutes les instances de cette struct/class. Si une instance modifie cette variable, la modification aura lieu dans toutes les instances de ce type.
struct		struct NomDeType { type variable1; type variable2; ... type variableN; } nomDeVariable; Une struct est un ensemble de données ayant un lien les unes avec les autres. Créer une struct revient à créer un nouveau type, qui peut servir à déclarer des variables comme pour n'importe quel autre type (la déclaration peut également se faire dès la définition, comme pour nomDeVariable). Les variables variable1, ... variableN sont les variables membres de la structure : elle sont accessibles par l'opérateur point '.' et sont particulières à chaque instance de la struct : chaque instance à son propre jeu de variables, différent de celui des autres instances. Cependant, une variable membre déclarée static est partagée entre toutes les instances de la struct. Voir Structures, unions et énumérations de données
switch case default		switch(variable) { case valeur1: instruction1; break; case valeur2: instruction2; break; case valeurN: instructionN; break; default: instructionAutre; break; } Permet de tester une variable de type entier (variable) par rapport à un certain nombre de valeurs constantes entières (valeur1, valeur2 ... valeurN) et d'exécuter du code en fonction de la valeur correspondante. L'instruction break sort directement du bloc switch. Un case ne s'arrête pas au case suivant : s'il n'y a pas d'instruction break, l'exécution continue jusqu'à la fin du switch, passant par toutes les instructions. Si aucune valeur donnée ne correspond à la valeur de variable, alors le cas default est appelé. Il Avoir un cas default n'est pas nécessaire, mais tout de même souhaitable. Voir Les structures de sélection : un peu plus loin.
typedef		typedef unsigned long int ulint; Crée un alias pour un type existant : pour l'exemple ci-dessus, ulint est un nouveau type, créé à partir du type unsigned long int, mais est considéré par le compilateur comme un type différent (ce qui permet de profiter du contrôle de typage du C++). Voir Structures, unions et énumérations de données
union		union NomDeType { type variable1; type variable2; ... type variableN; } nomDeVariable; Si l'union est syntaxiquement très proche de la struct, elle diffère de celle-ci par le fait que toutes les variables membres sont stockées à partir de la même case en mémoire, ce qui permet d'économiser de l'espace en mémoire, mais qui ne permet pas l'utilisation simultanée des membres. Voir Structures, unions et énumérations de données
void		Une fonction déclarée de type void est une fonction qui ne peut renvoyer de valeur. Ceci implique que l'utilisation de return avec une valeur provoque une erreur de compilation. Une fonction dont la liste des paramètres se résume à void est une fonction qui ne prend pas de paramètre. Un pointeur de type void ne pointe pas sur un type de donnée particulier. On doit alors faire une conversion si on veut effectuer une indirection.
while		while(condition) instructions; Exécute instructions tant que condition est vraie. La boucle peut être interrompue par break et continue permet de passer à l'itération suivante. Voir : Les boucles : jusqu'au stop !

Algorithme		Un algorithme est une description claire, complètement indépendante de l'ordinateur ou du langage de programmation utilisé, d'une suite de tâches élémentaires nécessaires à la résolution d'un problème donné. C'est l'algorithme qui va justifier la structure du programme.
Arbre		Un arbre est une structure de donnée complexe, possédant des propriétés de construction particulière : les éléments de l'arbre sont des noeuds. Chaque noeud peut avoir n fils, mais toujours un seul parent. C.f. La Puissance des Pointeurs : les Arbres
Chaîne de caractères		Une chaîne de caractères, ou string en anglais, est une séquence de caractères délimitée par des guillemets (ex: "ceci est une chaîne"). Toutes les chaînes de caractères contiennent un caractère de plus qu'il n'y paraît : elles sont toutes terminées par le caractère nul, '\0'. En fait, une chaîne de caractères est un tableau de caractères.
Compilateur		Un compilateur est un programme qui va traduire le code source écrit par le programmeur en langage machine, intelligible pour le processeur. Une fois compilé, le programme est exécutable. Pour l'exemple, Borland C++ ou Visual C++ sont deux compilateurs C++ différents.
Déclaration		En C++, une déclaration décrit au compilateur le type de l'objet défini et lui assigne un nom. On peut ainsi déclarer des variables, des classes, des fonctions, etc... Un objet ne peut pas être utilisé avant d'avoir été préalablement déclaré. La plupart du temps, les fonctions sont déclarées dans des fichiers d'en-tête .h. ex: int i;
Instance		Une instance de type est un exemplaire de variable de ce type. On parle d'instance surtout avec les objets construits à l'aide de struct ou de class.  Dans ce type d'objet, chaque instance possède (à moins que l'un d'eux ne soit déclaré static) sa propre copie de chaque membre de l'objet en question.
Liste chainee		Une liste chaînée est une liste d'éléments, dont la particularité est que chaque élément connait son successeur dans la liste (ceci est fait grâce aux pointeurs). Pour accéder à un élément, il faut parcourir toute la liste afin de pouvoir suivre les liens. Les avantages et les inconvénients des listes chaînées font l'objet du cours La puissance des pointeurs : les listes chaînées.
Programme		Un programme est un ensemble d'instructions, contenues dans un fichier, décrivant très précisément les tâches que doit effectuer l'ordinateur (et plus précisément le processeur). Ces instructions peuvent être celles d'un langage de programmation (avant compilation) ou celles du langage machine (après compilation).
Système d'exploitation		Un système d'exploitation est un programme fondamental dont le rôle principal est d'offrir à l'utilisateur un moyen d'utiliser son ordinateur. C'est lui qui gère les fichiers, qui lance l'exécution d'un programme, qui permet aux logiciels d'utiliser les différents périphériques (notemment le clavier et la souris)... On peut dire que sans sytème d'exploitation, vous ne pourriez pas faire grand chose avec votre ordinateur. Windows, Linux, BeOS, Unix sont autant d'exemples de systèmes d'exploitation.