Discussion :

[lg_53]

Bonjour à tous.

Ci dessus je vous présente un bout de code bateau divisé en 3 fichiers:
main.cc

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#include <iostream>
#include <string>
 
#include "MaClasse.h"
 
int main( int argc, char* argv[] ){
		MaClasse obj(30,20);
		std::cout << "Hello World!" << std::endl;
}

MaClasse.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
 
int Somme(int a, int b);
 
class MaClasse {
public:
		MaClasse(int x, int y);
		~MaClasse(){};
 
private:
		int _x,_y;
};

MaClasse.cc

Code :

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

1
2
3
4
5
#include "Maclasse.h"
 
int Somme(int a, int b){return a+b;}
 
MaClasse::MaClasse(int x, int y){std::cout << "Hey!" << std::endl; _x=x;_y=y;}

En compilant ceci (sous MAC) avec la commande:
c++ main.cc MaClasse.cc
là pas de problème.

Si maintenant, au lieu de définir ma fonction Somme dans le .cc je mets la définition directement dans le header, mes fichiers MaClasse .h et .cc deviennent :
MaClasse.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
 
int Somme(int a, int b){return a+b;};
 
class MaClasse {
public:
		MaClasse(int x, int y);
		~MaClasse(){};
 
private:
		int _x,_y;
};

MaClasse.cc

Code :

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

1
2
3
#include "Maclasse.h"
 
MaClasse::MaClasse(int x, int y){std::cout << "Hey!" << std::endl; _x=x;_y=y;}

Et là à la compilation j'ai l'erreur suivante :

duplicate symbol __Z5Sommeii in:
/var/folders/_0/4j2nn15x44s9cys_2hyct4vc0000gq/T/main-3bc424.o
/var/folders/_0/4j2nn15x44s9cys_2hyct4vc0000gq/T/MaClasse-6ec5ac.o
ld: 1 duplicate symbol for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

Quelqu'un pourrait-il m'éclairer ?

Merci

[ternel]

C'est un détail méconnu.

Ton header est inclus dans main.cc et MaClasse.cc.
Chacun de ses fichiers sources est compilé en une "unité de compilation", et deviennent main.o et MaClasse.o (ou autre dénomination windowsienne)

comme le code de la fonction est dans MaClasse.h, il est présent dans main.o et dans MaClasse.o

Du coup, à l'édition de lien, qui est en gros une mise bout à bout des .o, tu as deux fois le même code.
C'est précisément le message indiqué par le linker (ld):

duplicate symbol __Z5Sommeii
...
ld: 1 duplicate symbol

Tu remarqueras au passage le nom du symbole, qui Sommeii qui signifie Somme, prenant deux arguments: un int, puis un int.

C'est une violation de la règle de la définition unique:

Un symbole utilisé doit être défini une et une seule fois.

Il n'y a que deux solutions:

• ne définir qu'une seule fois le symbole
• séparer le symbole en autant de symbole distincts que nécessaire (ici deux: un pour main.o et un pour maclasse.o)

La première solution consiste à déclarer la fonction dans le .h, mais ne la définir que dans MaClasse.o
La seconde solution consiste à marquer explicitement la fonction comme "privée à l'unité de compilation".
La troisième solution, intermédiaire, et probablement meilleure, permet de ne pas payer ce cout en définissant la fonction comme inlineLa raison pour laquelle tu n'as pas ce problème dans une classe, c'est parce que toutes les fonctions membres définies dans la déclaration de la classe sont automatiquement définies comme inline.

La solution inline se présente ainsi:

Code :

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

1
2
3
4
inline int Somme(int a, int b) {
    return a+b;
}
//...

Une variante du problème existe quand on définit une fonction membre après la déclaration.
La solution inline se présente ainsi:

Code :

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

1
2
3
4
5
6
 
struct Bidule {
    int one() const {return 1;}
    int two() const;
}
inline int Bidule::two() const {return 2;}

Enfin, il est bon de savoir qu'une template doit être intégralement inline, et donc sa définition intégralement incluse dans l'unité de compilation concernée.
C'est pour cela que les templates sont intégralement définies dans leur en-tête.
C'est aussi pour cela que la STL est header-only.

[lg_53]

Merci pour vos réponses rapides et complètes

Il n'y a que deux solutions:

• ne définir qu'une seule fois le symbole
• séparer le symbole en autant de symbole distincts que nécessaire (ici deux: un pour main.o et un pour maclasse.o)

La première solution consiste à déclarer la fonction dans le .h, mais ne la définir que dans MaClasse.o
La seconde solution consiste à marquer explicitement la fonction comme "privée à l'unité de compilation".
La troisième solution, intermédiaire, et probablement meilleure, permet de ne pas payer ce cout en définissant la fonction comme inline

La première solution consiste à déclarer la fonction dans le .h, mais ne la définir que dans MaClasse.o <-- Tu ne veux pas dire plutot MAClasse.cc ?
Car définir qqch dans un .o, j'ai jamais fait ni entendu parler...

Effectivement avec le inline, ça fonctionne.
Du coup, dois-je prendre l'habitude de mettre inline devant toute fonction définie dans un header en dehors d'une classe ou bien est-ce plus subtil que cela ?

Merci à vous

[ternel]

C'est une bonne solution.
Cependant, ça n'est bon que lorsque la fonction reste lisible, sinon, de toute façon, la fonction sera trop complexe, et le compilateur ne l'inlinera pas.

Personnellement, je me limite aux fonctions limités à un return.
Ca peut éventuellement étendu aux fonctions en une ligne.
par exemple les surcharge de operator<<(ostream&, type const&).

Pour le reste, je mets la fonction dans le fichier d'implémentation.


Quant à la différence entre .cc et .o, il n'y en a quasiment aucune.
Comme tu n'inclue que des .h, chaque .o est le compilé d'un unique .cc.

J'en profite pour te signaler qu'en général, on utilise l'extension .cpp plutôt que .cc.
Et certains (moi inclus) utilise .hpp pour les en-têtes C++.

[Invité]

Bonjour,
Pour ce genre de problème, j'utilise des directives de compilation. Exemple simple, je doit écrire une fichier header qui s'appelle divers.h. Il aura cette forme

Code :

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

1
2
3
4
5
6
#ifndef divers_H
#define divers_H
/*
les prototypes qu'on veut
*/
#endif

Je pense que cette écriture est tout à fait standard.

[ternel]

Ca ne protège pas du même problème.

inline ou le namespace anonyme protègent contre les doubles définitions entre unités différentes.

La garde protège contre la double inclusion dans la même unité de compilation.
Ca protège donc contre les erreurs de compilations (multiple definition of ... / previous definition at ...)


la garde est utile par exemple quand tu écris

Code Bidule.hpp :

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

1
2
#include <string>
std::string version();

Code Bidule.hpp :

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

1
2
3
#include "Bidule.hpp"
#include <string>
std::string version() {return "ALPHA";}

Ici, <string> est inclus deux fois, mais comme il y a une garde à l'intérieur, le code contenu n'est écrit qu'une seule fois par le préprocesseur, et donc compilé qu'une seule fois.

D'ailleurs, c'est pour ca que dans ton .h, tu as précisé que tu mets les prototypes que tu veux. C'est à dire des déclarations de fonctions, et pas leurs définitions.

[lg_53]

Merci pour ces compléments très instructifs.

lg53

[cob59]

Puisque Somme est une fonction, il existe aussi cette solution-là :

Code :

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

1
2
3
static int Somme(int a, int b) {
    return a+b;
}

static (qui n'a pas la même signification ici que dans une classe) permet de dire au compilo que Somme n'existe que pour l'unité de compilation courante. Donc MaClasse.o détiendra 1 implémentation "locale" de Somme, de même que main.o.

[ternel]

C'est la deuxième solution, que je n'avais pas écrite, parce qu'elle n'est normalement pas à utiliser dans un en-tête.

Il y a techniquement mieux: le namespace anonyme.
Cela remplit le même rôle, mais pose moins de soucis lors de la recherche de nom.
En fait, ce static-là (classe de mémorisation) ne devrait jamais être utilisé.

Le namespace anonyme s'utilise ainsi:

Code :

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

1
2
3
namespace /*pas de nom ici*/ {
int Somme(int a, int b) {return a+b;}
}

Cependant, l'avantage de la fonction inline, c'est qu'elle est annoncée au compilateur comme candidate au remplacement dans le code.
Ce qui veut dire que le binaire compilé ne contiendrait même pas la fonction.

Au lieu d'avoir l'équivalent de ceci:

Code :

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

1
2
3
4
5
6
7
8
9
//compilation de int a=1, b=2, c = Somme(a, b);
registre a = 1;
registre b = 2;
a sur la stack
b sur la stack
appel de __Z5Sommeii
stack[return] = stack[0] + stack[1]
return
registre c depuis la stack

on aura certainement

Code :

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

1
2
3
4
//compilation de int a=1, b=2, c = Somme(a, b);
registre a = 1;
registre b = 2;
registre c = a + b

Et si le compilateur estime qu'il ne veut pas inliner la fonction, tout se passe comme s'il créait une autre unité de compilation, rien que pour elle.