Comment définir une fonction en C++?

Je voudrais une fonction qui n'est pas membre d'une classe et est accessible à partir de n'importe quelle classe.

Je suppose que j'aurais à #include le fichier d'en-tête où la fonction est déclarée, mais je ne sais pas où pour définir une telle fonction globale.

Sont là de bonnes raisons contre le fait d'avoir une telle fonction en premier lieu?

OriginalL'auteur Cory Klein | 2011-07-29

c++function global

24

vous avez besoin d'un corps (dans un cpp fichier):
```
int foo()
{
    return 1;
}
```
et une définition/prototype dans un fichier d'en-tête, qui sera inclus avant toute utilisation de la fonction:
```
#ifndef MY_FOO_HEADER_
#define MY_FOO_HEADER_
    int foo();
#endif
```
ensuite à l'aide d'ailleurs:
```
#include foo.h
void do_some_work()
{
    int bar = foo();
}
```
ou l'utilisation d'une fonction inline (ne garantit pas que ce sera inline, mais utile pour les petites fonctions, comme foo):
```
#ifndef MY_FOO_HEADER_
#define MY_FOO_HEADER_
    inline int foo()
    {
        return 1;
    }
#endif
```
sinon, vous pouvez aussi abuser de la C-style d'en-tête de base de fonctions (donc cela va dans un en-tête, le static forces qu'elle existe dans une seule unité de compilation seulement, vous devriez éviter cela, cependant):
```
#ifndef MY_FOO_HEADER_
#define MY_FOO_HEADER_
    static int foo()
    {
        return 1;
    }
#endif
```
Pourquoi devriez-vous éviter d'utiliser static pour forcer la fonction d'exister que dans une seule unité de compilation?
généralement provoque beaucoup de confusion, de l'esp. statique des fonctions globales, cela peut conduire à des comportements indésirables ou de la mauvaise utilisation, plus important encore, si vous êtes à l'aide de C++, alors vous devriez le code en C++, ce qui signifie en utilisant un en-tête avec un prototype (qui est peut-être marqué comme extern) et un fichier source avec la mise en œuvre, cela apporte aussi quelques effets secondaires, grâce à la façon dont les en-têtes sont traités.
Vous m'avez sauvé beaucoup de temps de l'ennui. J'ai suivi ce lien qui a eu beaucoup plus de temps et la même solution que vous avez donné. Le vôtre est clair et concis. Apprécié
est-il de mal à utiliser le "extern" lorsque la fonction a été déclarée et définie dans un autre fichier cpp, mais accessible? Ou est-ce correct? "extern int foo();" Il compile parfaitement, mais votre explication fait beaucoup plus de sens 🙂
Autant que je sache, le extern est superflu, sauf pour les modèles (voir C++11 extern modèle)

OriginalL'auteur Necrolis
4

Ce que vous appelez fonction globale est généralement appelé un fonction libre et ils sont Une Bonne Chose.

Vous définir comme une classe de fonction de membre, mais à l'extérieur de la classe'.
```
double squared(double x) {
    return x*x;
}
```
Simples fonctions que vous pouvez définir avec le inline mot-clé dans le fichier d'en-tête, ou simplement déclarer il y
```
double squared(double x);
```
et de mettre la mise en œuvre (premier exemple) dans la *.cpp fichier.

OriginalL'auteur Benjamin Bannier
3

Dans un fichier d'en-tête:
```
//someheader.h
#ifndef MY_GLOBAL_FUN
#define MY_GLOBAL_FUN

void my_global_fun();    

#endif
```
Dans un fichier de mise en oeuvre:
```
#include "someheader.h"

void my_global_fun()
{
    //...
}
```
Dans d'autres fichiers qui nécessitent de la fonction:
```
#include "someheader.h"

void f()
{
    my_global_fun();
}
```
Libre de fonctions de ce genre sont utiles et il n'y a pas beaucoup d'arguments à l'encontre de leur utilisation. Selon votre cas d'utilisation, il est probable approprié de mettre ces fonctions dans un namespace pour éviter les collisions de noms avec d'autres bibliothèques que vous utilisez peut-être.

Je suis encore en train un des symboles non définis erreur pour my_global_fun() et j'ai mis en place mes fichiers exactement comme vous l'aviez indiqué. Pouvez-vous vérifier que ce code a fonctionné pour vous? De toutes les réponses sur ce sujet DONC je trouve votre faire le plus de sens.
Il y a beaucoup de raisons pour lesquelles cela peut échouer. Quelle plate-forme, le compilateur et de commande (à construire) utilisez-vous?

OriginalL'auteur Chad
0

Pense de main(). La fonction est un peu juste...là. Ce n'est pas à l'intérieur de chaque classe, struct ou de l'espace. Vous venez de déclarer et de lui donner un corps. Bien sûr, dans le cas de fonctions qui ne sont pas principaux, il est préférable de mettre un prototype dans un en-tête et de le définir dans un .fichier cpp.

Rappelez-vous, C n'ont pas de classes et les structures ne pourraient pas tenir des fonctions membres. Il n'y a rien de mal avec gratuit fonctions et il n'y a pas maintenant.

OriginalL'auteur MGZero
0

Vous devez déclarer son prototype dans le fichier d'en-tête et de le définir dans le fichier d'implémentation.
```
//file.h
void foo();

//file.cpp
void foo ()
{}
```
À peu répondre à votre deuxième question, les fonctions Globales sont nécessaires lorsqu'ils sont utilisés par plusieurs différents types et classes de manière générique. Par exemple les fonctions mathématiques.

Sinon, en général, vous pouvez éviter ainsi de nombreuses fonctions globales. En outre, vous devriez éviter d'avoir un static membre local ou mondial, les données associées à cette fonction (de sorte que vous n'avez pas à vous soucier de la sécurité des threads).

OriginalL'auteur iammilind
0

En plus de la réponse par @Necrolis, l'utilisation de la statique est déconseillée en faveur de sans nom les espaces de noms. Cependant, l'utilisation de sans nom d'espace de noms et statique crée à la fois des copies séparées pour chaque unité de traduction, ce qui augmente la taille du binaire. L'utilisation en ligne est mieux que deux dans ce sens.

Ces solutions permettent d'usage plus spécifique des optimisations par les compilateurs, mais sont moins cache d'instructions convivial par rapport à la définition dans un fichier source, puis en liant.

OriginalL'auteur Utkarsh Bhardwaj

Vous devez vous connecter pour publier un commentaire.