Program voyage;

Salut
Déjà faut commencer par modéliser ton programme en UML. Le mieux est de faire de la programmation orientée objet. Tu fais une classe par éléments en gros. Une classe pour une personne, une classe pour l'avion, une classe pour l'aéroport, etc. Tu définis les méthodes dont tu risques d'avoir besoin. Ensuite pour coder, cela te paraitra beaucoup plus simple. Tu comptes le faire en quel langage ? Java, C++ ?

Donc vu que tu parles de pointeur j'imagine que tu veux écrire un programme en C ? Dans tout les cas il ne faut pas se dire je vais utiliser telle "techno" pour faire un programme, c'est plutôt le contraire : en écrivant ton programme tu vois si tu as besoin de pointeur ou non...

De toute façon comme tu ne décris pas très précisément le programme que tu souhaites réaliser c'est difficile de te répondre.

Bonne chance

slt!
merci bcp pr vos reponses!! et j'utilise c++

En C++ tu peux la plupart du temps te passer des pointeurs, en jouant sur la notion d'horizon (scope) :
Exemple :

int f(){ // <-- Début horizon
  float f;
  { // <-- Début horizon
    int x;
    plop_t plop();
    //...
  } // <-- Fin horizon : plop est désalloué au même titre que x
} // <-- Fin horizon :  f est désalloué

L'un des intérêts des pointeurs, c'est de pouvoir modifier les paramètres d'une fonction (via leur adresse, ie le pointeur) chose que tu peux faire avec une référence. A noter qu'en C ou C++ quand tu appelles une fonction, les paramètres sont en fait des recopies, et c'est pourquoi ce genre de manip est nécessaire
- on recopie l'adresse, mais pas l'objet pointé donc celui-ci est "modifiable" dans la fonction
- on recopie une adresse généralement beaucoup plus petite en mémoire que l'objet pointé

Exemple :

#include <iostream>

// Version qui ne marche pas
void inc(int x){ // x est une recopie de x0
  ++x; // seule la recopie 'x' est incrémentée -> aucun effet sur x0
}

// Version avec pointeur
void inc1(int *px){
  ++(*px); // l'adresse de x0 (&x0) est recopiée dans px, 
  // mais px == &x0, donc en manipulant *px je manipule bien x0
}

// Version avec référence
void inc2(int & x){
  ++x; // une référence se manipule syntaxiquement comme l'objet 
  // pointé mais tout se passe comme si on manipulait son adresse
  // une référence doit toujours être initialisée.
}

int main(){
  int x0 = 0;
  inc(x0); // pas incrémenté
  std::cout << x0 << std::endl;
  inc1(&x0); // OK
  std::cout << x0 << std::endl;
  inc2(x0); // OK
  std::cout << x0 << std::endl;
  return 0;
}

Tout ce petit speech pour te dire qu'il ne faut pas te focaliser sur le fait "dois-je ou non utiliser des pointeurs" car il existe plein de manières de programmer ;)

merci beaucoup!! ça m'eclairssie la façon dont je dois proceder!