Discussion :

[jjeuvrey]

Bonjour,
Je suis débutant en C++ et j'essaye de découper mon programme en fonctions.
Avant que je le découpe il fonctionnait, après il ne fonctionne plus.

la structure de mon programme
1)avant:
Dans le main.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
bool init(); // Appel de la fonction
bool init() // La fonction
{}
int main (int argc, char*args[]) // fonction main

2) après:
Dans le main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#include init.h
 
bool init();
int main (int argc, char*args[])

Dans le init.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
#include init.h
 
bool init() // la fonction
{}

Dans le init.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

bool init(); // déclaration de la fonction

Voyez vous déjà une erreur dans ma démarche?
merci!

[dalfab]

La démarche est correcte (mais il lever le bool init();qui serait resté dans main.cpp)

Après quand tu dis, "après il ne fonctionne plus" est-ce ça ne compile plus ou est-ce que le code ne fait plus la même chose?
Tu peux aussi mettre le texte exact de tes 4 fichiers en utilisant la balise bouton [#] car il y pas assez de données visibles ici pour t'aider.

[onilink_]

Il faut bien comprendre la nuance entre déclaration du prototype de la fonction et implémentation de la fonction.

Un programme C++ est séparé en modules (.cpp) et headers.
Chaque module contiens ses implémentations de fonctions, et peut être compilé en parallèle à d'autres modules.
Mais pour qu'un module connaisse les fonctions "publiques" des autres modules, il fait les déclarer dans des headers.
Sans cela le compilateur ne peut pas savoir si une fonction utilisée par un module, et implémentée dans un autre module existe ou non.
Sans prototype il va juste donner une erreur du genre "fonction non existante".

En revanche, il est aussi tout a fait possible de déclarer un prototype de fonction, et appeler cette fonction, sans qu'elle n'existe dans aucun module.
La compilation de chaque module se fera d'ailleurs sans problème, mais c'est lors de la phase de construction de l’exécutable que le linker va donner une erreur de la forme:
"undefined reference of XXX"

En bref:
-"undefined reference of" => la fonction a un prototype de déclaré, mais n'a pas d'implémentation, il faut implémenter celle ci dans un module (.cpp)
-"XXX was not declared" => la fonction n'a pas de prototype ou implémentation déclarée dans le module, il faut déclarer le prototype de la fonction dans un header et l'include au module
-"multiple definition of" => la fonction a été implémentée plusieurs fois, le linker ne sait donc pas laquelle linker. Il faut utiliser le mot clé static (en C) ou un namespace anonyme (c++) pour qu'une fonction soit locale a un module (et donc privée)

[koala01]

Humm... Tu as presque tout bon, sauf pour la dernière ligne:

-"multiple definition of" => la fonction a été implémentée plusieurs fois, le linker ne sait donc pas laquelle linker. Il faut utiliser le mot clé static (en C) ou un namespace anonyme (c++) pour qu'une fonction soit locale a un module (et donc privée)

La meilleure solution est -- toujours -- de veiller à ce qu'il n'y ait qu'une seule et unique implémentation de la fonction. Cela signifie donc qu'il faut ... supprimer l'implémentation qui correspond le moins bien aux besoins recherchés par la fonction

Après, il reste le cas de fonctions que l'on doit -- pour une raison ou une autre -- implémenter dans le fichier d'en-tête (*.h ou *.hpp) et non dans un fichier d'implémémentation (*.cpp).

Pour éviter le problème, on les déclarera inline

[Bousk]

Dans ton premier code, ton "appel à la fonction" est une erreur: ceci est la déclaration du prototype de la fonction.

[onilink_]

Humm... Tu as presque tout bon, sauf pour la dernière ligne:

La meilleure solution est -- toujours -- de veiller à ce qu'il n'y ait qu'une seule et unique implémentation de la fonction. Cela signifie donc qu'il faut ... supprimer l'implémentation qui correspond le moins bien aux besoins recherchés par la fonction

Après, il reste le cas de fonctions que l'on doit -- pour une raison ou une autre -- implémenter dans le fichier d'en-tête (*.h ou *.hpp) et non dans un fichier d'implémémentation (*.cpp).

Pour éviter le problème, on les déclarera inline

En effet, mais je parlais plus du cas général du "gros projet", ou un élément global de même nom se trouve dans plusieurs modules, alors qu'il devrait être "privé"/caché.

J'ai aussi oublié de préciser qu'il faut faire attention a ne pas placer des implémentations dans un header, vu que justement elles seront compilées dans chaque module ou a été inclus dans le header (et on aura une erreur de linker).
On peut en revanche se le permettre avec des templates ou des fonctions inline. Cela peut avoir pas mal d'avantages.

[foetus]

Tu as oublié les include guard (<- lien Wiki)