Photographie/Fabricants/Fujitsu
Mini-disques durs portatifs.
Handydrive.
La nouvelle série de disques durs portatifs externes Handydrive de 2,5 pouces et 3,5 pouces avec interface USB 2.0 offre des capacités de 80 et 120 Go. Ces disques durs sont plats, mesurent 136,3 mm x 72,5 mm x 13,5 mm et pèsent moins de 200 grammes. L'interface USB 2.0, alimentée directement via le bus, permet de connecter et déconnecter rapidement le disque. Elle autorise des débits de données allant jusqu'à 60 Mo/seconde. Une mémoire-tampon de 8 Mo et un temps d'accès moyen de 12 ms constituent de bonnes performances. 
Pour assurer la résistance aux chocs et vibrations, les disques sont montés non pas sur des roulements, mais sur des paliers lisses hydrodynamiques.

Programmation C-C++/Référencement, indirection

Référencement, indirection.
Un pointeur ne servirait strictement à rien s'il n'y avait pas de possibilité d'accéder à l'adresse d'une variable ou d'une fonction (on ne pourrait alors pas l'initialiser) ou s'il n'y avait pas moyen d'accéder à l'objet référencé par le pointeur (la variable pointée ne pourrait pas être manipulée ou la fonction pointée ne pourrait pas être appelée).
Ces deux opérations sont respectivement appelées "référencement" et "indirection" (ou "déréférencement"). Il existe deux opérateurs permettant de récupérer l'adresse d'un objet et d'accéder à l'objet pointé. Ces opérateurs sont respectivement & et *.
Il est très important de s'assurer que les pointeurs que l'on manipule sont tous initialisés (c'est-à-dire contiennent l'adresse d'un objet valide, et pas n'importe quoi). En effet, accéder à un pointeur non initialisé revient à lire ou, plus grave encore, à écrire dans la mémoire à un endroit complètement aléatoire (selon la valeur initiale du pointeur lors de sa création). En général, on initialise les pointeurs dès leur création, ou, s'ils doivent être utilisés ultérieurement, on les initialise avec le pointeur nul. Cela permettra de faire ultérieurement des tests sur la validité du pointeur ou au moins de détecter les erreurs. En effet, l'utilisation d'un pointeur initialisé avec le pointeur nul génère souvent une faute de protection du programme, que tout bon débogueur est capable de détecter. Le pointeur nul se note NULL.
Note : NULL est une macro définie dans le fichier d'en-tête stdlib.h. En C, elle représente la valeur d'une adresse invalide. Malheureusement, cette valeur peut ne pas être égale à l'adresse 0 (certains compilateurs utilisent la valeur -1 pour NULL par exemple). C'est pour cela que cette macro a été définie, afin de représenter, selon le compilateur, la bonne valeur. Voir le chapitre "le préprocesseur" pour plus de détails sur les macros et sur les fichiers d'en-tête.
La norme du C++ fixe la valeur nulle des pointeurs à 0. Par conséquent, les compilateurs C/C++ qui définissent NULL comme étant égal à -1 posent un problème de portabilité certain, puisque un programme C qui utilise NULL n'est plus valide en C++. Par ailleurs, un morceau de programme C++ compilable en C qui utiliserait la valeur 0 ne serait pas correct en C.
Il faut donc faire un choix : soit utiliser NULL en C et 0 en C++, soit utiliser NULL partout, quitte à redéfinir la macro NULL pour les programmes C++ (solution qui me semble plus pratique). 
Exemple - Déclaration de pointeurs.
Il est à présent facile de comprendre pourquoi il faut répéter l'étoile dans la déclaration de plusieurs pointeurs :
 int *p1, *p2, *p3;
signifie syntaxiquement : p1, p2 et p3 sont des pointeurs d'entiers, mais aussi *p1, *p2 et *p3 sont des entiers.
Si l'on avait écrit :
 int *p1, p2, p3;
seul p1 serait un pointeur d'entier. p2 et p3 seraient des entiers.
L'accès aux champs d'une structure par le pointeur sur cette structure se fera avec l'opérateur '->', qui remplace '(*).'.

Programmation C-C++/Notion de référence
Notion de référence.
En plus des pointeurs, le C++ permet de créer des références. Les références sont des synonymes d'identificateurs. Elles permettent de manipuler une variable sous un autre nom que celui sous laquelle cette dernière a été déclarée.
Note : Les références n'existent qu'en C++. Le C ne permet pas de créer des références. 
Par exemple, si « id » est le nom d'une variable, il est possible de créer une référence « ref » de cette variable. Les deux identificateurs id et ref représentent alors la même variable, et celle-ci peut être accédée et modifiée à l'aide de ces deux identificateurs indistinctement.
Toute référence doit se référer à un identificateur : il est donc impossible de déclarer une référence sans l'initialiser. De plus, la déclaration d'une référence ne crée pas un nouvel objet comme c'est le cas pour la déclaration d'une variable par exemple. En effet, les références se rapportent à des identificateurs déjà existants.
La syntaxe de la déclaration d'une référence est la suivante :
 type &référence = identificateur;
Après cette déclaration, référence peut être utilisé partout où identificateur peut l'être. Ce sont des synonymes.
Exemple - Déclaration de références.
Il est possible de faire des références sur des valeurs numériques. Dans ce cas, les références doivent être déclarées comme étant constantes, puisqu'une valeur est une constante :

Programmation C-C++/Lien entre les pointeurs et les références

Lien entre les pointeurs et les références.
Les références et les pointeurs sont étroitement liés. En effet, une variable et ses différentes références ont la même adresse, puisqu'elles permettent d'accéder à un même objet. Utiliser une référence pour manipuler un objet revient donc exactement au même que de manipuler un pointeur constant contenant l'adresse de cet objet. Les références permettent simplement d'obtenir le même résultat que les pointeurs, mais avec une plus grande facilité d'écriture.
Cette similitude entre les pointeurs et les références se retrouve au niveau syntaxique. Par exemple, considérons le morceau de code suivant :
et faisons passer l'opérateur & de la deuxième ligne à gauche de l'opérateur d'affectation :
Maintenant, comparons avec le morceau de code équivalent suivant :
Nous constatons que la référence ri peut être identifiée avec l'expression *pi, qui représente bel et bien la variable i. Ainsi, la référence ri encapsule la manipulation de l'adresse de la variable i et s'utilise comme l'expression *pi. Cela permet de comprendre l'origine de la syntaxe de déclaration des références. La différence se trouve ici dans le fait que les références doivent être initialisées d'une part, et que l'on n'a pas à effectuer le déréférencement d'autre part. Les références sont donc beaucoup plus faciles à manipuler que les pointeurs, et permettent de faire du code beaucoup plus sûr.

Programmation C-C++/Passage de paramètres par variable ou par valeur