Quand on commence à programmer dans un langage donné, le point de départ est souvent le "Hello world" qui permet de connaître les éléments indispensables même pour le plus élémentaires des programmes. C'est un peu la naissance d'un programme, il découvre le monde…

cf. Hello world sur Wikipedia

Le Hello world permet aussi de s'assurer que l'on peut commencer à programmer. Si on arrive à écrire le fichier helloworld.c puis à le compiler et à exécuter helloworld.exe, c'est que notre installation est opérationnelle et que l'on peut commencer à programmer.

Le programme que l'on va considérer se résumerait à ceci en Python :

# helloworld.py
print("Hello world")

Et pour l'exécuter, il faut utiliser un interpréteur python. On pourrait écrire en ligne de commande :

python helloworld.py

Cela veut dire qu'il faut que le logiciel interpréteur soit installé sur la machine, c'est lui qui traduit à la volée le contenu du fichier texte helloworld.py.

Je me place dans l'idée de la ligne de commande parce que c'est plutôt cela que l'on ferait pour l'équivalent C. Mais avec Python, on a plutôt l'habitude d'utiliser un environnement comme Pyzo ou Edupython dans lequel on dispose d'une console et on a même pas l'embarras d'écrire la ligne de commande.

// fichier helloworld.c
#include <stdio.h>

int main() {
  printf("Hello World\n");
  return 0;
}

// fichier helloworld.c
#include <stdio.h>

int main() {
  printf("Hello World\n");
  return 0;
}

Simple commentaire. Tout ce qui suit // est ignoré. On peut aussi utiliser des commentaires multi-lignes commençant avec /* et terminant avec */.

Chargement d'une bibliothèque. C'est une bibliothèque standard qui concerne les entrées / sorties - input / output. Donc stdio = standard input / output.

On en a besoin pour afficher des caractères à l'écran, c'est à dire pour la fonction printf rencontrée plus loin.

int main() {

et accolade fermante } en ligne 7

C'est la définition d'une fonction. Cette fonction s'appelle main, elle doit renvoyer un int (un entier).

• Contrairement à Python qui utilise les indentations pour indiquer ce qui est dans la fonction et ce qui n'y est pas, on utilise ici des accolades. La fonction commence avec { et termine avec }

• main est une fonction spéciale. On est obligé d'en avoir une dans le programme. Elle indique ce qui sera exécuté quand on lancera le programme.

Quand on lance en ligne de commande helloworld.exe, c'est la fonction `main` qui est exécutée.

printf("Hello World\n");

• On a déjà dit que printf permet un affichage à l'écran. On verra plus tard que c'est une fonction plus compliquée à utiliser que le print de Python.

• On reconnaît le caractère "\n" qui représente une fin de ligne.

Remarquez que rien n'est affiché à l'écran tant que l'on n'a pas atteint "\n".

Ce code par exemple n'affiche rien : printf("Hello");

Et dans le code suivant, c'est quand on atteint "\n" que l'affichage se produit :

    printf("Hello");
    printf(" world !\n");

Remarquez enfin la présence du caractère ; en fin d'instruction.

Contrairement à Python pour lequel on doit changer de ligne à chaque instruction, en C on pourrait tout écrire sur une seule ligne. Ce code par exemple est tout à fait valable :

int main(int argc, const char *argv[]) {printf("Hello World\n");return 0;}

    return 0;

On l'a déjà signalé, la fonction main est déclarée comme int main, elle doit donc renvoyer un entier. L'absence d'un return renvoyant un entier serait une erreur.

main étant une fonction spéciale, on est obligé de lui faire renvoyer un entier. L'entier renvoyé permet d'informer le système du bon déroulement du programme.

• Si le retour est 0, alors le programme s'est bien déroulé, il n'y a pas d'erreur.
• Si le retour est autre chose que 0, par exemple 1, alors il y a une erreur. Vous pouvez d'ailleurs modifier le retour en écrivant return 1, recompiler puis exécuter. Vous verrez un message d'erreur.

Pour l'exécuter… C'est plus difficile. C n'est pas un langage interprété. Il est compilé.

Au lieu de traduire à la volée au moment de l'exécution, on traduit une fois pour produire un fichier *.exe. Ce fichier devient exécutable sans avoir besoin d'autre chose. Il faut donc un compilateur…

Le compilateur classique est gcc - GNU compiler collection

Il faut utiliser un terminal, aller dans le répertoire ou se trouve le fichier *.c et lancer :

gcc -Wall -o helloworld helloworld.c

L'option -Wall permet de provoquer l'affichage des éventuelles erreurs.

La compilation produit le fichier helloworld qui est exécutable. On peut lancer ./helloworld pour exécuter.

Sur linux, les spécialistes ne jurent que par emacs qui est un éditeur de texte complètement configurable et avec le quel on peut à peu près tout faire. J'avoue que je ne m'y suis jamais mis…

Le principe est le même. Il faudrait installer un compilateur comme gcc et l'exécuter en ligne de commande.

Le mieux est sans doute d'utiliser le portage de gcc sur windows. Vous pouvez utiliser MinGW

Le lien mène à une page qui explique comment utiliser notepad++ pour configurer la compilation. Ainsi notepad++ agit comme un environnement qui simplifie la compilation.

Dans windows, les fichiers exécutables reçoivent l'extension *.exe. La compilation devrait donc produire un fichier *.exe. Dans la configuration proposée dans le lien MinGW ci-dessus, le fichier produit s'appelle output.exe.

// fichier helloworld.c
#include <stdio.h>

int main(int argc, const char *argv[]) {
  printf("Hello World\n");
  return 0;
}

Il y a une complication dans la déclaration de main en ligne 4.

Pour comprendre à quoi correspondante argc et argv il faut se rappeler que l'on exécutera le programme après compilation en exécutant le programme compilé, par exemple helloworld.exe ce que l'on peut faire en ligne de commande.

En ligne de commande on peut ajouter des options, des arguments : helloworld.exe -f truc. Lors du lancement de cette ligne, on va produire un tableau contenant des chaînes de caractères avec chaque élément de la ligne :

{"helloworld.exe", "-f", "truc"}

argc et argv permettent de recevoir ce tableau :

• argc est un entier (comme l'indique la déclaration int argc) qui contient le nombre d'éléments du tableau. Ici 3.
• argv est le tableau lui-même.
  • const indique que le contenu du tableau ne pourra être changé,
  • les [] indiquent que c'est un tableau. On ne précise pas ici la taille de ce tableau car ce tableau est déjà réservé en mémoire et on n'a pas donc pas besoin de savoir quelle taille réserver.
  • Chaque élément du tableau argv est de type char *, il s'agit donc de pointeurs sur caractère, donc de tableaux de caractères, soit encore des chaînes de caractères.