Programme C :

$ cat fichier.c
#include <stdio.h>

int main()
{
printf("Hello world !\n");
return 0;
}
$ gcc -o programme fichier.c
$ ./programme
Hello world !
$

Programme C++ :

$ cat fichier.cpp
#include <iostream.h>
 
int main()
{
cout << "Hello world !" << endl;
return 0;
}
$ g++ -o programme fichier.cpp
$ ./programme
Hello world !
$

L'option -o utilisée par gcc et g++ permet de spécifier le nom de l'exécutable.

Il faut compiler le projet avec l'option -g (il est important de passer tous les fichiers en argument), puis de lancer gdb.

A noter qu'il existe également un débuggeur graphique : ddd (Display Data Debugger), normalement présent sur votre distribution.

Les sources d'un programme peuvent comprendre beaucoup de fichiers, incorporer des librairies, etc. Taper à la main les lignes de compilation de chacun des fichiers peut donc devenir très fastidieux.
Pour simplifier les compilations de projets sous Unix, il existe l'utilitaire make : il permet d'interpréter un fichier de dépendance entre les différents éléments nécessaires à la création d'un projet. Ce fichier est appelé Makefile.
Un makefile définit les relations entre des fichiers, et établit les dépendances nécessaires à la création d'autres fichiers. Si, pour créer un fichier A, il faut utiliser un fichier B, alors il va d'abord falloir créer le fichier B.
Le travail de make est essentiellement de vérifier les dates des fichiers pour déterminer quels sont ceux qui sont à jour et ceux qu'il faut recréer afin de générer le projet. Pour chacun des fichiers à recréer, make détermine, grâce au makefile, les librairies à lier, et les arguments à passer à gcc puis lance la compilation.
Make simplifie beaucoup le travail du programmeur, puisqu'au lieu de taper les argument de gcc à chaque compilation, il suffit de lancer make.
En général, les fichiers makefile contiennent une cible nommée all, qui permet de générer tout le projet.
Make peut aussi être utilisé dans un autre contexte que la programmation : il permet d'effectuer des commandes de mises à jour de fichiers qui dépendent de la mise à jour d'autres fichiers.

Ajouter dans .bashrc la ligne.

PATH=$PATH:. 

et lance un nouveau terminal. Ainsi, en cherchant le programme demandé dans chaque répertoire de la variable d'environnement PATH, le shell va trouvé ce programme dans le répertoire courant (le répertoire .)

Pour tous les codeurs Java qui aiment leur pingouins, voici la méthode qui leur permettra de télécharger et installer le JDK sous Linux :
1) Téléchargez le JDK de Sun.
2) Attribuez-lui le droit d'être exécuté

chmod +x NOM_DE_VOTRE_JDK 

3) Exécutez-le et installez de ce fait votre JDK.
4) Attention, c'est là que ça devient chaud. Il va vous falloir configurer 2 variables globales importantes : PATH et CLASSPATH. Ouvrez votre fichier .bashrc (situé dans votre home) et ajoutez les lignes suivantes :

export PATH=$PATH:.:/chemin/de/votre/JDK/bin 
export CLASSPATH=.:/chemin/de/votre/JDK/lib/tools.jar 

5) C'est fini ! Codez bien !!!
6) NB : pour ceux qui veulent généraliser PATH et CLASSPATH pour tous leurs utilisateurs, éditez les 2 lignes mentionnées dans /etc/profile.

A partir de la version 1.5 Tiger, il n'y a plus à s'occuper de CLASSPATH.

Un fichier pipe permet (entre autres) de faire dialoguer plusieurs processus entre eux sans pour autant générer par exemple des fichiers temporaires.

mknod /tmp/fichier_pipe p

ou

mkfifo /tmp/pipe