Français/SON et SONT
Astuce.
SON et SONT
Explication grammaticale.
"son" est un déterminant (ou adjectif) possessif, tandis que "sont" est la troisième personne du pluriel à l'indicatif présent du verbe être. Le premier précédera donc toujours un substantif (il pourra ainsi se trouver dans quasi n'importe quel groupe grammatical), alors que le second sera toujours la base d'une proposition ou l'auxiliaire d'un verbe à un temps composé.
Exemple :

Français/CE et SE
Astuce.
CE et SE
Explication grammaticale.
"se" est un pronom réfléchi de la troisième personne (singulier ou pluriel ; il sert également à l'infinitif), tandis que "ce" est un adjectif (ou déterminant) ou pronom démonstratif. Le premier sera donc toujours accompagné d'un verbe et d'un sujet, tandis que le deuxième précédera un substantif ou sera sujet (si le pronom occupe d'autres fonctions, on utilisera "cela", "ceci", "c", ou, en langage parlé, "ça").
Exemple :

Programmation C/Classe de stockage
Il est possible de construire des types dérivés des types de base du langage en utilisant plusieurs combinaisons, deux étant illustrées dans ce chapitre: les classes de stockage et les qualificateurs.
Classe de stockage.
Le langage C permet de spécifier, avant le type d'une variable, un certain nombre de "classes de stockage" : 
Les classes codice_4 et codice_2 sont, de loin, les plus utilisées. codice_3 est d'une utilité limitée, et codice_1 est maintenant obsolète.
Une variable, ou un paramètre de fonction, ne peut avoir qu'au plus une classe de stockage.
Classe 'static'.
L'effet de la classe 'static' dépend de l'endroit où l'objet est déclaré :
Exemple :
void f(void)
 static int i = 0; /* i sera initialisée à 0 à la compilation seulement */
 int j = 0; /* j sera initialisée à chaque appel de f */;
 i++;
 j++;
 printf("i vaut %d et j vaut %d.\n", i, j);
int main(void)
 f();
 f();
 f();
 return 0;
Résultat d'exécution du code ci dessus :
i vaut 1 et j vaut 1.
i vaut 2 et j vaut 1.
i vaut 3 et j vaut 1.
Il est déconseillé de redéfinir plusieurs fois la même variable statique dans différents blocs, car le résultat peut être surprenant :
void toto(void) {
 static char toto = 'A';
 printf("deb fun: %c\n", toto);
 printf("deb block: %c\n", toto);
 static char toto = 'M';
 printf("fin block: %c\n", toto);
 toto ++;
 toto++;
 printf("fin fun: %c\n", toto);
int main(void)
 toto();
 toto();
 return 0;
Affiche
On voit que la durée de vie de la variable de bloc statique ne commence qu'à partir de sa déclaration, même si la déclaration n'est exécutée qu'une fois au cours du programme.
Une variable de classe statique est initialisée au moment de la compilation à zéro par défaut (contrairement aux variables dynamiques qui ont une valeur initiale indéterminée). Elle peut être initialisée explicitement à n'importe quelle valeur "constante".
Classe 'extern'.
codice_2 permet de "déclarer" une variable sans la "définir". C'est utile pour la compilation séparée, pour définir une variable ou une fonction dans un fichier, en permettant à des fonctions contenues dans d'autres fichiers d'y accéder.
Toutes les variables globales et fonctions qui ne sont pas déclarées (ou définies) codice_4 sont externes par défaut.
codice_4 et codice_2 sont employés pour distinguer, dans un fichier C, les objets et fonctions « privés », qui ne doivent être utilisés que depuis l'intérieur du fichier, et ceux qui sont « publics », et pourront être accessibles depuis d'autres fichiers.
Classe 'register'.
L'usage de ce mot clé est utile dans un contexte de logiciel embarqué.
Indique que la variable devrait être stockée dans un registre du processeur. Cela permet de gagner en performance par rapport à des variables qui seraient stockées dans un espace mémoire beaucoup moins rapide, comme une pile placée en mémoire vive.
Ce mot-clé a deux limitations principales :
Aujourd'hui, ce mot-clé est déconseillé sauf pour des cas particuliers, les compilateurs modernes sachant généralement mieux que le programmeur comment optimiser et quelles variables placer dans les registres.
int main(void)
 register short i, j;
 for (i = 1; i < 1000; ++i)
 for(j = 1; j < 1000; ++j)
 printf("\n %d %d", i, j);
 return 0;
Classe 'auto'.
Cette classe est un héritage du langage B. En C, ce mot-clé sert pour les variables locales à une fonction non-statiques, dites aussi "automatiques". Mais une variable déclarée localement à une fonction sans qualificateur codice_4 étant implicitement automatique, ce mot-clé est inutile en C.
Qualificateurs.
Le C définit trois qualificateurs pouvant influer sur une variable : 
Une variable, ou un paramètre de fonction, peut avoir aucun, un, deux, ou les trois qualificateurs (certaines combinaisons n'auraient que peu de sens, mais sont autorisées).
Qualificateur 'const'.
La classe codice_16 ne déclare pas une vraie constante, mais indique au compilateur que la valeur de la variable ne doit pas changer. Il est donc impératif d'assigner une valeur à la déclaration de la variable, sans quoi toute tentative de modification ultérieure entrainera une erreur de la part du compilateur :
const int i = 0;
i = 1; /* erreur*/
En fait, le mot-clé codice_16 est beaucoup plus utilisé avec des pointeurs. Pour indiquer qu'on ne modifie pas l'objet pointé, il est bon de spécificier le mot-clé codice_16 :
void fonction( const char * pointeur )
 pointeur[0] = 0; /* erreur*/
 pointeur = "Nouvelle chaine de caractères";
Dans cet exemple, on indique que l'objet pointé ne sera pas modifié. Pour indiquer que la valeur elle-même du pointeur est constante, il faut déclarer la variable de la sorte :
char * const pointeur = "Salut tout le monde !";
pointeur = "Hello world !"; /* erreur*/
Encore plus subtil, on peut mélanger les deux :
const char * const pointeur = "Salut tout le monde !";
pointeur = "Hello world !"; /* erreur*/
pointeur[0] = 0; /* erreur*/
Cette dernière forme est néanmoins rarement usitée. En outre ce dernier exemple présente un autre problème qui est la modification d'une chaîne de caractères « en dur », qui sont la plupart du temps placées dans la section lecture seule du programme et donc inaltérables.
Attention codice_16 n'est pas une protection réelle contre les changements de valeur, qu'elles proviennent d'un comportement indéfini, ou de constructions valides du C telle que
const char lettre = 'A';
memset(&lettre, 'B', 1);
putchar(lettre); /* affiche B */
En outre certaines constructions du C même si elles n'indiquent pas être codice_16 le sont effectivement.
int nombres[3] = {1, 2, 3};
int * autres_nombres;
nombres = autres_nombres; /* erreur à la compilation, l’adresse d'un tableau ne peut pas être modifié */
char * phrase = "Salut tout le monde !";
phrase[0] = 's'; /* erreur probable à l'exécution, une chaîne de caractères littérale ne peut pas être modifiée */
Qualificateur 'volatile'.
Ce mot-clé sert à spécifier au compilateur que la variable peut être modifiée à son insu. Cela annule toute optimisation que le compilateur pourrait faire, et l'oblige à procéder à chaque lecture ou écriture dans une telle variable tel que le programmeur l'a écrit dans le code. Ceci a de multiples utilisations :
On peut combiner codice_16 et codice_18 dans certaines situations. Par exemple :
déclare une variable entière, qu'on ne peut modifier à partir du programme, mais dont la valeur peut changer quand même. Elle pourrait désigner une valeur incrémentée régulièrement par une horloge interne.
Qualificateur 'restrict'.
Introduit par C99, ce mot-clé s'applique aux déclarations de pointeurs uniquement. Avec "restrict", le programmeur certifie au compilateur que le pointeur déclaré sera le seul à pointer sur une zone mémoire. Cela permettra au compilateur d'effectuer des optimisations qu'il n'aurait pas pu "deviner" autrement. Le programmeur ne doit pas "mentir" sous peine de problèmes...
Par exemple :