Inférence de type et compilateurs
Salut,
Ce matin je me suis penché sur un problème dans un code qu'a reçu un collègue. D'un côté dans un header, on définit un type pour un ensemble de pointeurs fonction qui sont déclarés comme "extern" ce_type. Dans le source, les fonctions sont implémentées et les pointeurs vers ces fonctions sont initialisés. Et clang et g++ n'ont pas le même comportement sur le code en question, clang accepte et g++ râle par ce qu'il considère que les types de matchent pas.
Voici un code minimaliste reproduisant le problème (j'ai omis les headers guards pour la concision) :
Code:
1
2
3
4
5
6
| //function.hh
#include <type_traits>
using my_type = std::add_pointer<void(int)>::type;
extern my_type my_function; |
Code:
1
2
3
4
5
6
| //function.cc
#include "function.hh"
auto foo(int) {}
auto my_function = foo; |
Résultat de la compilation avec g++ :
Code:
1
2
3
4
5
6
7
| $ g++ -c function.cc -std=c++14
function.cc:5:6: error: conflicting declaration ‘auto ma_fonction’
auto ma_fonction = foo;
^
In file included from function.cc:1:0:
function.hh:4:16: note: previous declaration as ‘void (* ma_fonction)(int)’
extern my_type ma_fonction; |
Le plus étrange, c'est que si dans le source on remplace le auto par un decltype, il arrête de grogner :
Code:
1
2
3
4
5
| #include "function.hh"
auto foo(int) {}
decltype(foo)* ma_fonction = foo; |
Quelqu'un a-t-il une explication à ce phénomène ?
Qui de g++ et de clang est le plus dans son droit d'accepter ou de râler ?
Merci.
