Question de base C++ concernant la portée des fonctions

Question

Je commence tout juste à apprendre le C++, donc vous devrez supporter mon ignorance. Existe-t-il un moyen de déclarer des fonctions telles qu'elles peuvent être référencées sans être écrites avant la fonction qui les utilise. Je travaille avec un fichier cpp (pas ma décision) et mes fonctions s'appellent elles-mêmes donc il n'y a pas vraiment d'ordre approprié pour les placer. Un moyen de # définir les fonctions avant qu'elles ne soient utilisées ou quelque chose comme ça? Ou peut-être un moyen de les étiqueter avec un opérateur de portée qui n'implique pas qu'ils font partie d'une classe?

Merci à l'avance

Answer 1

Vous pouvez écrire la fonction prototypes avant de les mettre en œuvre. Un prototype de fonction nomme une fonction, son type de retour et le type de ses arguments. La seule chose qui doit être au-dessus de l'appel à votre fonction est le prototype. Voici un exemple:

// prototype 
int your_function(int an_argument); 

// ... 
// here you can write functions that call your_function() 
// ... 

// implementation of your_function() 
int your_function(int an_argument) { 
    return an_argument + 1; 
} 

Answer 2

Oui. Mettez la signature de la fonction en haut du fichier ou dans un fichier d'en-tête (.h).

Alors:

void OtherFunc(int a); 

void SomeFunc() 
{ 
    OtherFunc(123); 
} 

void OtherFunc(int a) 
{ 
    ... 
} 

Answer 3

Je pense que vous faites référence est un prototype de fonction .

C'est là que vous définissez le prototype d'une fonction dans le fichier d'en-tête , mais définir la mise en œuvre dans un fichier source (Cpp).

Le code source qui doit référencer la fonction inclut simplement le fichier d'en-tête, qui fournit suffisamment d'informations pour que le compilateur corrèle l'appel de fonction aux arguments et renvoie la valeur de la fonction que vous appelez. La fonction "symbole" n'est résolue que sur le fichier source si la fonction l'implémentation n'existait pas à ce stade, vous obtiendrez un symbole non résolu.

Voici un exemple:

fichier de bibliothèque en-tête - library.h

// This defines a prototype (or signature) of the function 
void libFunction(int a); 

fichier Source des bibliothèques (Cpp) - library.cpp

// This defines the implementation (or internals) of the function 
void libFunction(int a) 
{ 
    // Function does something here... 
} 

code client

#include "library.h" 
void applicationFunction() 
{ 
    // This function call gets resolved against the symbol at the linking stage 
    libFunction(); 
} 

Answer 4

Membre de la classe les fonctions sont déclarées dans l'en-tête qui définit l'interface de la classe. Ce fichier d'en-tête doit être inclus au début ou à la fin du fichier CPP qui inclut l'implémentation. Ainsi, peu importe l'ordre dans lequel les fonctions membres sont définies dans le fichier CPP car toutes les déclarations ont déjà été incluses.

De votre question, j'imagine que vous envisagez d'écrire des fonctions gratuites. Vous pouvez utiliser la même technique pour déclarer des fonctions libres; Cependant, je préviens contre trop de fonctions gratuites.

Answer 5

Ce dont vous avez besoin est une fonction déclaration (aka prototype). Une déclaration est le type de retour, le nom et la liste d'arguments d'une fonction sans corps. Ce sont généralement dans les fichiers d'en-tête, mais ils ne doivent pas être. Voici un exemple:

#include<stdio> 
using namespace std; 

void bar(int x); // declaration 
void foo(int x); // declaration 

int main() { 
    foo(42);  // use after declaration and before definition 
    return 0; 
} 

void foo(int x) { // definition 
    bar(x);  // use after declaration and before definition 
} 

void bar(int x) { // definition 
    cout << x; 
}