Discussion :

[3DArchi]

Bonjour,
Suite à une autre discussion, j'ai fait l'exemple suivant :
a.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef A_H_INCLUDED
#define A_H_INCLUDED
struct A
{
   static inline void inline_de_A();
};
 
inline void inline_globale();
 
void misc();
 
#endif // A_H_INCLUDED

a.cpp:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include "a.h"
#include <iostream>
 
void A::inline_de_A()
{
   std::cout<<"inline_de_A dans a.cpp"<<std::endl;
}
 
void inline_globale()
{
   std::cout<<"inline_globale dans a.cpp"<<std::endl;
}
 
void misc()
{
   A::inline_de_A();
   inline_globale();
}

main.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "a.h"
#include <iostream>
 
void A::inline_de_A()
{
   std::cout<<"inline_de_A dans main.cpp"<<std::endl;
}
 
void inline_globale()
{
   std::cout<<"inline_globale dans main.cpp"<<std::endl;
}
 
int main()
{
   misc();
   A::inline_de_A();
   inline_globale();
   return 0;
}

Je n'ai aucune erreur à la compilation et au link (Visual&MinGW).
La définition utilisée est à priori celle de main.
Si je supprime les définitions dans main.cpp mais je crée un doublon dans un b.cpp, alors la définition prise est celle de a.cpp.
J'ai le sentiment que le compilateur? linker? supprime toujours une des deux définitions, mais je n'arrive pas à déterminer sur quel critère.

D'où ma question : comment cela s'articule avec le ODR (One Definition Rule) ? Quelle définition est choisie ? Je n'arrive pas à trouver dans la norme ce qui peut répondre à ça.
Merci.

[JolyLoic]

Ta fonction inline est définie par une séquence de tokens différente à deux endroits. Tu violes l'ODR. Tu as un comportement indéfini.

[3DArchi]

Ta fonction inline est définie par une séquence de tokens différente à deux endroits. Tu violes l'ODR.

C'est un peu mon sentiment aussi.
En fait, j'ai trouvé ça dans la norme qui devrait s'appliquer ici :

There can be more than one definition of a [...] inline function
with external linkage (7.1.2) [...] in a program provided that each
definition appears in a different translation unit, and provided the definitions satisfy the following requirements.
[...]— each definition of D shall consist of the same sequence of tokens; [...]

Tu as un comportement indéfini.

C'est ce que j'aurais tendance à dire.

Cependant, aucun compilateur (MinGW et Visual) ne râle alors qu'il a normalement les billes pour détecter la double définition. C'est ce qui me trouble.

[Médinoc]

Pour Visual, ce n'est pas étonnant qu'il ne gueule pas, vu qu'une fonction inline est par défaut statique.
Pour gcc, le linker devrait pouvoir gueuler en effet...

[3DArchi]

Pour Visual, ce n'est pas étonnant qu'il ne gueule pas, vu qu'une fonction inline est par défaut statique.

Qu'entends-tu par statique ? Elle n'est pas spécifique à une unité de compilation mais bien commune à tout l'exécutable. Je n'ai pas compris ce que tu voulais dire

[Médinoc]

Hé ben si: Sous Visual, par défaut, une fonction inline est spécifique à une unité de compilation.

[3DArchi]

inline_f.h :

Code :

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

1
2
#pragma once
inline void fonction();

a.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include "inline_f.h"
#include <iostream>
 
void fonction()
{
   std::cout<<"fonction dans a.cpp"<<std::endl;
}
 
void DoA()
{
   fonction();
}

b.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include "inline_f.h"
#include <iostream>
 
void fonction()
{
   std::cout<<"fonction dans b.cpp"<<std::endl;
}
 
void DoB()
{
   fonction();
}

main.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "inline_f.h"
#include <iostream>
 
void fonction()
{
   std::cout<<"fonction dans main.cpp"<<std::endl;
}
 
extern void DoA();
extern void DoB();
int main()
{
   fonction();
   DoA();
   DoB();
    return 0;
}

Sortie (Visual Express):

fonction dans main.cpp
fonction dans main.cpp
fonction dans main.cpp

Il n'y a bien qu'une seule définition de retenue à la fin ? Ou j'ai loupé quelque chose ?

[Médinoc]

Ah ben merde alors, c'est encore plus bizarre...

[Médinoc]

Functions that are declared as inline, and that are not class member functions, have internal linkage unless otherwise specified.

[koala01]

Salut,

Et une question idiote, comment arrive-t-on à spécifier le contraire (autrement dit, comment arrive-t-on à spécifier qu'une fonction libre inline ne doit pas être considérée statique par le compilateur)

Ceci dit, j'ai l'impression que les deux compilateurs envisagés se "vautrent" royalement sur ce coup là...

Car, si on en croit la norme, un code proche de
fichier test.h

Code :

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

1
2
3
inline void foo();
void aTest();
void bTest();

fichier a.cpp

Code :

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

1
2
3
4
5
6
7
8
9
#include <test.h>
inline void foo()
{
    cout<<"appel depuis un A"<<endl;
}
void aTest()
{
    foo();
}

fichier b.cpp

Code :

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

1
2
3
4
5
6
7
8
9
#include <test.h>
inline void foo()
{
    cout<<"appel depuis un B"<<endl;
}
void aTest()
{
    foo();
}

fichier main.cpp

Code :

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

1
2
3
4
5
6
7
#include <test.h>
int main()
{
    aTest();
    bTest();
    return 0;
}

devrait donner le résultat

Code :

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

1
2
appel depuis un A
appel depuis un B

non

(maintenant, il est possible que je comprenne la norme de travers )

[3DArchi]

non

En fait c'est ce que dit Loïc : le comportement est indéterminé.
La norme précise :

There can be more than one definition of a [...] inline function
with external linkage (7.1.2) [...] in a program provided that each
definition appears in a different translation unit, and provided the definitions satisfy the following requirements.
[...]— each definition of D shall consist of the same sequence of tokens; [...]

Là ce sont des séquences différentes. Donc on tombe à côté de la norme. Conclusion : le comportement est indéterminé. Et ici, cette indétermination me semble relever d'un choix du compilateur au moment de la génération.

[Médinoc]

Salut,

Et une question idiote, comment arrive-t-on à spécifier le contraire (autrement dit, comment arrive-t-on à spécifier qu'une fonction libre inline ne doit pas être considérée statique par le compilateur)

Je n'ai pas essayé, mais je suppose que "extern" fait peut-être l'affaire.

[3DArchi]

Je n'ai pas essayé, mais je suppose que "extern" fait peut-être l'affaire.

Ben il suffit de reprendre ta citation du MSDN (au fait, le lien est invalide) :

Functions that are declared as inline, and that are not class member functions, have internal linkage unless otherwise specified.

[Médinoc]

Je viens de tester rapidement ceci sur un projet Visual 2008 existant:

Code C/C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
 
#pragma once
 
#include "targetver.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <tchar.h>
 
#ifndef EXTERN_C
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C extern
#endif
#endif
 
// TODO: reference additional headers your program requires here
#ifdef __cplusplus
extern inline void UneFonctionInline(int);
#endif

Code C++ :

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

1
2
3
4
5
6
7
//UneFonctionInline.cpp
#include "stdafx.h"
 
extern inline void UneFonctionInline(int a)
{
	a *= 2;
}

Code C++ :

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

1
2
3
4
5
6
7
//TestUneFonctionInline.cpp
#include "stdafx.h"
 
void TestUneFonctionInline(void)
{
	UneFonctionInline(42);
}

Avec un main() dans un fichier source non montré ici, ça compile et ça linke sans problème.
Évidemment, la fonction n'est pas inlinée dans TestUneFonctionInline.cpp...