Programmation C-C++/Exemple de programme

Exemple de programme complet.
Le programme suivant est donné à titre d'exemple. Il calcule la moyenne de deux nombres entrés au clavier et l'affiche :
Exemple - Programme complet simple.
Programme en C :
int main(void)
 long double x, y;
 printf("Calcul de moyenne\n"); /* Affiche le titre. */
 printf("Entrez le premier nombre : ");
 scanf("%Lf", &x); /* Entre le premier nombre. */
 printf("\nEntrez le deuxième nombre : ");
 scanf("%Lf", &y); /* Entre le deuxième nombre. */
 printf("\nLa valeur moyenne de %Lf et de %Lf est %Lf.\n",
 x, y, (x+y)/2);
 return 0;
Dans cet exemple, les chaînes de format spécifient des flottants (f) en quadruple précision (L).

Programmation C-C++/La structure if
La structure conditionnelle if.
La structure conditionnelle "if" permet de réaliser un test et d'exécuter une instruction ou non selon le résultat de ce test. Sa syntaxe est la suivante :
où "test" est une expression dont la valeur est booléenne ou entière. Toute valeur non nulle est considérée comme vraie. Si le test est vrai, "opération" est exécuté. Ce peut être une instruction ou un bloc d'instructions. Une variante permet de spécifier l'action à exécuter en cas de test faux :
Note : Attention ! Les parenthèses autour du test sont nécessaires ! 
Les opérateurs de comparaison sont les suivants :
Les opérateurs logiques applicables aux expressions booléennes sont les suivants :
Il n'y a pas d'opérateur ou exclusif logique.
Exemple - Test conditionnel if.
if (a<b && a!=0)
 m=a;
 nouveau_m=1;

Programmation C-C++/La boucle for
La boucle for.
La structure de contrôle "for" est sans doute l'une des plus importantes. Elle permet de réaliser toutes sortes de boucles et, en particulier, les boucles itérant sur les valeurs d'une variable de contrôle. Sa syntaxe est la suivante :
où "initialisation" est une instruction (ou un bloc d'instructions) exécutée avant le premier parcours de la boucle du "for". "test" est une expression dont la valeur déterminera la fin de la boucle. "itération" est l'opération à effectuer en fin de boucle, et "opération" constitue le traitement de la boucle. Chacune de ces parties est facultative.
La séquence d'exécution est la suivante :
Exemple - Boucle for.
Note : En C++, il est possible que la partie "initialisation" déclare une variable. Dans ce cas, la variable déclarée n'est définie qu'à l'intérieur de l'instruction "for." Par exemple,
est strictement équivalent à :
Cela signifie que l'on ne peut pas utiliser la variable "i" après l'instruction "for", puisqu'elle n'est définie que dans le corps de cette instruction. Cela permet de réaliser des variables muettes qui ne servent qu'à l'instruction "for" dans laquelle elles sont définies.
Note : Cette règle n'est pas celle utilisée par la plupart des compilateurs C++. La règle qu'ils utilisent spécifie que la variable déclarée dans la partie "initialisation" de l'instruction "for" reste déclarée après cette instruction. La différence est subtile, mais importante. Cela pose assurément des problèmes de compatibilité avec les programmes C++ écrits pour ces compilateurs, puisque dans un cas la variable doit être redéclarée et dans l'autre cas elle ne le doit pas. Il est donc recommandé de ne pas déclarer de variables dans la partie "initialisation" des instructions "for" pour assurer une portabilité maximale.

Programmation C-C++/Le while
Le while.
Le "while" permet d'exécuter des instructions en boucle tant qu'une condition est vraie. Sa syntaxe est la suivante :
où "opération" est effectuée tant que "test" est vérifié. Comme pour le "if", les parenthèses autour du "test" sont nécessaires. L'ordre d'exécution est :
Exemple - Boucle while.
somme = i = 0; /* initialisation des variables somme et i à la valeur 0 */
while (somme<1000) /* exécution tant que la valeur somme est inférieure à 1000 */
 somme = somme + 2 * i / (5 + i); /* modification de la valeur somme par ajout d'une valeur dépendant de i */
 i++; /* incrémentation de la variable i (i++ est une écriture condensée d'incrémentation de la variable i, équivalente à i = i + 1, la dernire forme étant à préférer, pour des raisons de lisibilité */

Programmation C-C++/Le do
Le do.
La structure de contrôle "do" permet, tout comme le "while," de réaliser des boucles en attente d'une condition. Cependant, contrairement à celui-ci, le "do" effectue le test sur la condition après l'exécution des instructions. Cela signifie que les instructions sont toujours exécutées au moins une fois, que le test soit vérifié ou non. Sa syntaxe est la suivante :
"opération" est effectuée jusqu'à ce que "test" ne soit plus vérifié.
L'ordre d'exécution est :

Programmation C-C++/Branchement conditionnel

Dans le cas où plusieurs instructions différentes doivent être exécutées selon la valeur d'une variable de type intégral, l'écriture de "if" successifs peut être relativement lourde. Le C/C++ fournit donc la structure de contrôle "switch", qui permet de réaliser un branchement conditionnel. Sa syntaxe est la suivante :
"valeur" est évalué en premier. Son type doit être entier. Selon le résultat de l'évaluation, l'exécution du programme se poursuit au cas de même valeur. Si aucun des cas ne correspond et si "default" est présent, l'exécution se poursuit après "default". Si en revanche "default" n'est pas présent, on sort du "switch".
Les instructions qui suivent le "case" approprié ou "default" sont exécutées. Puis, les instructions "du cas suivant" sont également exécutées (on ne sort donc pas du "switch"). Pour forcer la sortie du "switch", on doit utiliser le mot clé "break".
Exemple - Branchement conditionnel switch.
Note : Il est interdit d'effectuer une déclaration de variable dans un des "case" d'un "switch".

Programmation GTK2 en Pascal/GtkHSeparator

Présentation.
Le contrôle GtkHSeparator permet de dessiner une ligne horizontale 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_hseparator_new : PGtkWidget;
Il n'y a rien de plus à dire à propos de ce contrôle.
Programme exemple.
Voilà le fichier codice_1 :
 program gtk040;
 uses glib2, gtk2;
 var
 pFenetre : PGtkWidget;
 pVBox : 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), 'Gtk040 : Séparateur');
 gtk_signal_connect(G_OBJECT(pFenetre), 'destroy', G_CALLBACK(gtk_main_quit), NULL);
 // Création de la GtkVBox
 pVBox := gtk_vbox_new(FALSE, 5);
 gtk_container_add(GTK_CONTAINER(pFenetre), pVBox);
 // Création du label 1
 pLabel1 := gtk_label_new('Label 1');
 gtk_box_pack_start(GTK_BOX(pVBox), pLabel1, FALSE, FALSE, 0);
 // Création du séparateur
 pSeparateur := gtk_hseparator_new;
 gtk_box_pack_start(GTK_BOX(pVBox), pSeparateur, FALSE, FALSE, 0);
 // Création du label 2
 pLabel2 := gtk_label_new('Label 2');
 gtk_box_pack_start(GTK_BOX(pVBox), pLabel2, FALSE, FALSE, 0);
 gtk_widget_show_all(pFenetre);
 gtk_main;
 end.
Voilà ce que donne l'exécution du programme codice_2 :

Programmation GTK2 en Pascal/GtkVSeparator