Modules à la manière VBA ?

Bonsoir à tous,
Existe t-il un moyen simple d'écrire avec Code::Blocks, des fonctions dans un fichier autre que main.cpp mais pour autant utilisables comme si elles étaient écrites dans 'main.cpp', un peu à la manière de VBA. où il est possible d'ajouter des modules distincts qui contiennent des procédures qui restent à disposition tout en n'encombrant pas inutilement la procédure principale.
Dans l'onglet "Projets" de Code::Blocks, l’arborescence de l'espace de travail laisse supposer que le sous-répertoire "Sources" qui contient le sous-répertoire "main.cpp" pourrait contenir d'autres fichiers de fonctions qui une fois mises au points y resteraient stockées mais utilisables ?
L.P.

Parfaitement.
Ce que tu cherches s'appelle compilation séparée.

Le langage C++ n'est pas compilé en une seule étape.
Pour l'essentiel ca se passe en trois grandes étapes.

Supposons que tu veuilles compiler un certain nombre de fichiers .cpp pour former une application.
Chaque .cpp est compilé indépendamment, puis les résultats sont combinés ensembles.

Concrètement, chaque fichier .cpp est passé au préprocesseur, qui exécute les directives qui lui sont dédiés (chaque ligne commençant par un #) et remplace les mots correspondant à des macros par le texte de ces macros. C'est à ce moment que chaque #include est remplacé par le contenu du fichier inclus.

Puis ces fichiers traités sont compilés, produisant ce qu'on appelle souvent des fichiers "objets".
Dans ces fichiers objets, on a des fonctions définies, et des appels à des fonctions externes, qui sont supposées exister, mais pas définies ici, qu'on qualifie de "symboles non résolus".

Enfin, l'ensemble des ces fichiers sont réunis, et les différents symboles non définis sont reliés à leurs définitions.
C'est l'étape d'édition des liens.

Le résultat est un unique programme.

Pour répondre à ta question.
Tu définis une fonction f dans un fichier (arbitrairement je le nommerai fonction.cpp).
Tu écris aussi un fichier d'en-tête, qui ne fait que déclarer cette fonction. Tu appelles ce fichier fonction.h (le même nom de base que celui définissant la fonction)
Tu introduis en première ligne de fonction.cpp la directive #include "fichier.h", de façon à s'assurer que la compilation de l'en-tête soit correcte.
Dans main.cpp, tu ajoutes la même directive.

A présent, main.cpp déclare la fonction f, et fonction.cpp la déclare puis la définit.
A l'édition des liens, le compilateur reconnaitra que les deux fonctions f sont la même.

Pour continuer sur cette voie, regarde ce que sont:

• la garde contre double inclusion
• le mot clé extern
• les namespace anonyme, qui permet de rendre un symbole introuvable depuis l'exterieur d'une unité de compilation

Salut à tous et à 'ternel' en particulier,
C'est en fait une sorte de réflexe pavlovien (du à VBA) qui m'a amené à interroger sur cette question.
Comme je débute avec ces nouveaux outils et que mes marques ne sont pas faciles à trouver, je pense me simplifier un peu la tâche en limitant autant que possible 'la surface de travail' à la routine en cours de mise au point, évitant ainsi l'utilisation fréquente de l’ascenseur.
Par exemple, si le bout de code "Hello world" est compilé puis lancé depuis code::blocks la console ne se referme pas à la fin.
Mais si je lance l'exécutable depuis l'explorateur ce n'est plus le cas, sauf si j'ai rajouté une 'procédure' comme celle-ci que j'ai trouvé dans un exemple.

Code:

---

1 2 3 4 5 6 7

string consolePause() // declenche la PAUSE avec la console en direct depuis l'.exe { cout <<"Press Enter to Exit . . .\n"; cin.get(); cin.clear(); return ""; }

---

que j'appelle ensuite, juste avant le return 0; ( consolePause(); )En pratique donc comment enlever du fichier main.cpp les 6 lignes ci-dessus, pour les mettre dans un fichier du répertoire 'Sources' et l'appeler ci besoin.

Comment faire aussi pour passer d'éventuels paramètres (ce qui n'est pas le cas ici).
Un exemple serait le bienvenu.
Merci d'avance.
L.P.

S'il te plait regarde les Internets (:google:) pour les include c'est la première chose qu'on apprend.

Après, il y aura des choses plus avancées que tu apprendras en cours de route (que des définitions et pas de déclaration dans les entêtes, include guard, la déclaration des templates, que c'est juste un copié/ collé, ...)

Mais en gros (je n'ai pas compilé donc peut-être qu'il y aura des modifications pour compiler):
Tu vas avoir un fichier entête common.h (ou common.hpp pour dire que c'est une entête C++)

Code:

---

1 2 3 4 5 6 7 8 9 10

#ifndef COMMON_H #define COMMON_H   #include <string>     std::string consolePause();     #endif // COMMON_H

---

Tu vas avoir ton fichier source common.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include "common.h" // or #include "common.hpp"   #include <iostream>     using std::cout; using std::cin; using std::endl; using std::string;     string consolePause() { // declenche la PAUSE avec la console en direct depuis l'.exe cout << "Press Enter to Exit . . ." << endl; cin.get(); cin.clear();   return ""; }

---

Et ton source main.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include "common.h" // or #include "common.hpp"     int main(int argc, char* argv[]) { // ...   consolePause();   // ...   return 0; }

---

Après cet exemple c'est juste si tu mets tous tes fichiers dans le même dossier :mrgreen:.
Si tu mets les fichiers common.h[pp]/ common.cpp dans un autre dossier il faut changer l'include du fichier main.cpp.

Pour le passage de paramètre :mrgreen:, c'est aussi un truc qu'on apprend en premier (et en C++ il y a la surcharge)

Salut à tous et Merci à 'foetus' pour sa réponse.

(que je vais essayer de mettre en application dés que j'aurais peaufiné le code que j'ai posté sur le forum c++ à propos de la saisie contrôlée et bornée de floats)
L.P.

Merci à 'foetus' c'est OK.
Salut à tous,
L.P.