Comment est-ce qu'on fait pour écrire un programme en utilisant plusieurs fichiers .cpp  pour par exemple mettre le main dans un fichier, l'initialisation dans un autre, la gestion de quelque chose encore dans un autre, etc... Et qu'on puisse utiliser toutes les fonctions dans tous les fichiers?
 
Merci.

ds un .h tu mets les en-têtes des fonctions que tu mettras ds le .cpp correspondant
apres dans les .cpp tu fais des include des .h nécessaires
 
enfin ca c pr une utilisation tres basique, ca doit etre plus fin et "réglementé"

Passer en plusieurs fichiers nécessite d'être très propre.
 
Déjà, en Visual, il faut rajouter les fichiers sources au projet, avec la fonction appropriée dans les menus.
 
Ensuite, y'a deux choses qui posent problème : les données statiques, et les inclusions multiples, voires récursives. Il y donc deux choses à noter pour que les choses soient bien faîtes:
 
Il faut limiter les données statiques, et les définir une fois dans un fichier .cpp
 
exemple: (imaginons qu'on veuille faire un shoot'em up    
 
fichiermain.cpp
**********************
#include "MoteurJeu.h"
#include "MoteurAffichage.h"
#include <fstream>
using namespace std;
 
ofstream globaldebugfile;
 
void main()
{
   globaldebugfile.open("debug.log" );
   globaldebugfile << "Jeu lancé" << endl;
   MoteurAffichage mdisp;
   MoteurJeu mgame;
   mgame.SetRenderer(mdisp);
   while(true)
   {
     if (mgame.end())
       break;  
     mgame.OneFrame();
   }
}
 
*******************************
 
fichier MoteurJeu.h
 
********************************
//MoteurJeu.h
//
 
#ifndef __MoteurJeu_h__
#define __MoteurJeu_h__       //ceci assure que le fichier .h ne sera pas include plus d'une fois par accident. C'est la bonne manière de procéder, et les header standard l'utilisent. Ne pas oublier le #endif à la fin du fichier
 
class ObjetJeu
{...};
 
class vaisseau: public ObjetJeu
{...};
 
...
 
#endif //__MoteurJeu_h__ <- un petit commentaire pour rappeler à quoi se rattache le #endif
 
***********************************
 
 
fichier MoteurAffichage.h
********************************
//MoteurAffichage.h
 
#ifndef __MoteurAffichage_h__
#define __MoteurAffichage_h__
 
#include "MoteurJeu.h"  //ne crée pas d'inclusion récursive grâce au #ifndef
 
class Renderer...
 
class MoteurAffichage: public Renderer...
 
 
#endif //__MoteurAffichage_h__
 
**************************************
 
fichier MoteurJeu.cpp
*****************************************
#include "MoteurJeu.h"
 
extern ofstream globaldebugfile; //extern pour dire que l'on ne définit pas, mais que l'on rappelle qu'il existe déjà un objet dans un autre fichier qui s'appelle globaldebugfile
 
...//du code
 
 
 
 
 
 
 
 
**************************************
 
 
fichier "MoteurAffichage.h"
***********************
 
#include "MoteurAffichage.h"
#include "MoteurJeu.h"
 
...//du code
 
*****************************

sinon, il faut mettre le moins de classes que possible par fichier .cpp, histoire de rendre les choses plus lisibles. C'est chiant d'avoir à parcourir un fichier de 3000 lignes.
Mieux vaut avoir 100 fichiers simples.
 
Ensuite, il faut éviter les #include inutiles. C'est chiant par la suite auqnd on veut réutiliser le code. On pense qu'il y a des dépendances (alors qu'elles n'extistent pas en réalité)
 
Nommer le fichier par le nom de la classe principale du fichier n'est pas une mauvaise idée.
 
Ensuite, il faut se fixer des conventions de codage, ie, on indente de telle manière, les variables locales en minuscules, les noms de type avec une majuscule au début de chaque mot sans underscore, les constantes tout en majuscules avec underscores entre les mots...
Ces conventions de codage rendent le code bcp+ lisible.
 
Enfin, les classes avec templates doivent mettre tout le code dans le .h, pour des raisons évidantes. gcc permet de les inclure une fois seulement en objet pour gagner de la place.