Présentation.
Le contrôle GtkVSeparator permet de dessiner une ligne verticale entre des contrôles.
Utilisation de base.
Création.
Ce contrôle n'a qu'une seule fonction : sa fonction de création :
 function gtk_vseparator_new : PGtkWidget;
Il n'y a rien de plus à dire à propos de ce contrôle.
Programme exemple.
Voilà le fichier codice_1 :
 program gtk041;
 uses glib2, gtk2;
 var
 pFenetre : PGtkWidget;
 pHBox : PGtkWidget;
 pLabel1 : PGtkWidget;
 pSeparateur : PGtkWidget;
 pLabel2 : PGtkWidget;
 begin
 gtk_init(@argc, @argv);
 pFenetre := gtk_window_new(GTK_WINDOW_TOPLEVEL);
 gtk_window_set_position(GTK_WINDOW(pFenetre), GTK_WIN_POS_CENTER);
 gtk_window_set_default_size(GTK_WINDOW(pFenetre), 320, 200);
 gtk_window_set_title(GTK_WINDOW(pFenetre), 'Gtk041 : Séparateur');
 gtk_signal_connect(pGTKOBJECT(pFenetre), 'destroy', G_CALLBACK(@gtk_main_quit), NULL);
 // Création de la GtkHBox
 pHBox := gtk_hbox_new(FALSE, 5);
 gtk_container_add(GTK_CONTAINER(pFenetre), pHBox);
 // Création du label 1
 pLabel1 := gtk_label_new('Label 1');
 gtk_box_pack_start(GTK_BOX(pHBox), pLabel1, FALSE, FALSE, 0);
 // Création du séparateur
 pSeparateur := gtk_vseparator_new;
 gtk_box_pack_start(GTK_BOX(pHBox), pSeparateur, FALSE, FALSE, 0);
 // Création du label 2
 pLabel2 := gtk_label_new('Label 2');
 gtk_box_pack_start(GTK_BOX(pHBox), pLabel2, FALSE, FALSE, 0);
 gtk_widget_show_all(pFenetre);
 gtk_main;
 end.
Voilà ce que donne l'exécution du programme codice_2 :

Programmation C-C++/Rupture de séquence
Les commandes de rupture de séquence.
En plus du "goto" vu précédemment, il existe d'autres commandes de "rupture de séquence" (c'est-à-dire de changement de la suite des instructions à exécuter). Ces commandes sont les suivantes :
 continue;
ou
 break;
ou
 return [valeur];
"return" permet de quitter immédiatement la fonction en cours. Comme on l'a déjà vu, la commande "return" peut prendre en paramètre la valeur de retour de la fonction.
"break" permet de passer à l'instruction suivant l'instruction "while", "do", "for" ou "switch" la plus imbriquée (c'est-à-dire celle dans laquelle on se trouve).
"continue" saute directement à la dernière ligne de l'instruction "while", "do" ou "for" la plus imbriquée. Cette ligne est l'accolade fermante. C'est à ce niveau que les tests de continuation sont faits pour "for" et "do", ou que le saut au début du "while" est effectué (suivi immédiatement du test). On reste donc dans la structure dans laquelle on se trouvait au moment de l'exécution de "continue", contrairement à ce qui se passe avec le "break".

Enseignement de l'anglais/Animals, les animaux

Application.
Test de vocabulaire
Retour Enseignement de l'anglais

Programmation C-C++/Types avancés
Les pointeurs et références.
Les pointeurs sont des variables très utilisées en C et en C++.
Ils doivent être considérés comme des variables, il n'y a rien de sorcier derrière les pointeurs.
Cependant, les pointeurs ont un domaine d'application très vaste.
Les références sont des identificateurs synonymes d'autres identificateurs, qui permettent de manipuler certaines notions introduites avec les pointeurs plus souplement.
Elles n'existent qu'en C++.
Parlons d'abord de Pointeurs.
Voici un exemple de pointeur : int * pp; signifie que codice_1 est une variable qui contient un pointeur vers un entier, ou encore contient l'adresse d'un nombre entier.
On peut se poser la question, pour préciser le type pointé, ici codice_2 (entier), simplement par ce que le système fait des calculs d'adresse et doit connaître le déplacement à faire pour trouver l’élément suivant.
Regardons la différence entre les codes suivants :
double nbReel[4]= { 10.5, 17.5, 23, 56};
int nbEnt [4] = { 5, 6, 9, 44}; 
double *nb1; int *nb2;
nb1 = nbReel; 
nb2 = nbEnt;
Ici "nb1" reçoit l'adresse du tableau "nbReel", qu on peut aussi écrire nb1 = &nbReel[0]
nb1 + 1 est l’adresse du suivant. C'est-à-dire de nbReel[1], pour se fixer les idées, supposons que le tableau "nbReel" est implémenté en mémoire à l'adresse 1200, qui est donc l'adresse de nbReel[0], alors l'adresse de nbReel[1] est 1208 (ou encore nb1+1 est 1208), on ajoute 8, parce que la taille d'un nombre "double" est 8 octets (bytes). maintenant supposons que l'adresse de nbEnt[0] (même chose que nbEnt) soit 2200 alors adresse de nbEnt[1] est 2204, car la taille d'un entier est 4 octets. C'est-à-dire codice_3 est 2204.
De plus maintenant que le pointeur nb1 contient l'adresse de début de zone nbReel, on peut accéder à n'importe quel élément du tableau NbReel avec le pointeur nb1, 
par exemple : *nb1 représente l'objet pointe par nb1, c'est-à-dire valeur 10.5.
Et *(nb1+1) représente l'objet pointe par nb1 +1, c'est-à-dire valeur suivante : 17.5. Attention à la parenthèse ! *nb1 + 1 : veut dire on ajoute 1 à l'objet pointe par nb1 (on ajoute 1 au nombre réel 10.5 : ce qui donne 11.5).