C++0x : l'association d'espaces de noms
Bonjour,
J'ai beau lire la n2535 et la n1344, les inline namespace me semblent assez anecdotiques.
Effectivement, dans le code suivant, la différence de comportement pour l'appel de g peut surprendre :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| namespace Lib
{
namespace Lib_1
{
struct A{};
}
struct B{};
template <typename T> void g(T){}
}
int main()
{
Lib::Lib_1::A a;
g(a); // Erreur
Lib::B b;
g(b); // OK
return 0;
} |
Ne maîtrisant pas sur les doigts les name lookup et en particulier les argument-dependent name lookup, j'aurais de toute façon tendance à écrire :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| namespace Lib
{
namespace Lib_1
{
struct A{};
}
struct B{};
template <typename T> void g(T){}
}
int main()
{
Lib::Lib_1::A a;
Lib::g(a);
Lib::B b;
Lib::g(b);
return 0;
} |
Ce code fonctionne sans problème. Et je pense que j'aurais toujours tendance à écrire ce dernier code plutôt que celui-ci :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| namespace Lib
{
inline namespace Lib_1
{
struct A{};
}
struct B{};
template <typename T> void g(T){}
}
int main()
{
Lib::Lib_1::A a;
g(a);
Lib::B b;
g(b);
return 0;
} |
De la même façon, pour les spécialisations de template, j'écrirais plus volontiers la spécialisation dans l'espace de nom approprié :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
| namespace Lib
{
namespace Lib_1
{
template<class T>
struct A{};
}
struct B{};
namespace Lib_1
{
template<> struct A<B>{};
}
} |
qu'avec une association de nom :
Code:
1
2
3
4
5
6
7
8
9
10
| namespace Lib
{
inline namespace Lib_1
{
template<class T>
struct A{};
}
struct B{};
template<> struct A<B>{};
} |
Du coup, je me demande si je ne passe pas à côté de quelque chose avec cette évolution. Je n'arrive pas à vraiment saisir son intérêt.
Qu'en pensez-vous ?
