Discussion :

[camboui]

Bonjour,
Voici un petit code tout simple qui ne compile pas

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
template<class Chr>
void pointer_or_array(Chr const *rs)
{
	std::cout << rs << " size: ?" << std::endl;
}
 
template<class Chr, size_t Rswz>
void pointer_or_array(Chr const (&rs)[Rswz])
{
	std::cout << rs << " size: " << Rswz << std::endl;
}
 
int main()
{
	pointer_or_array("abc");//<- erreur ici pour cause d'ambiguïté
	char const *abc = "abc";
	pointer_or_array(abc);
	return 0;
]

J'aurais pourtant cru que les signatures étaient différentes et que les "string literal" étaient de type "character array" et non de type "character pointer".
Comment donc résoudre cette ambiguïté ?
Merci !

[prgasp77]

Bonjour, excellente question.

Bien que "abc" soit une prvalue de type const char[4], les deux instantiations suivantes sont valides :

Code :

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

1
2
template<> void pointer_or_array<char>(char const *rs)
template<> void pointer_or_array<char, 4>(char const (&rs)[4])

En effet, le decay du tableau en pointeur est considéré avant le choix du meilleur candidat. Les deux sont donc du même ordre.

Afin de résoudre cette ambiguïté, je vous propose d'appeler une instantiation explicite de votre fonction :

Code :

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

pointer_or_array<char, 4>("abc");

[Pyramidev]

Bonjour,

Voici une solution qui n'oblige pas l'appelant à préciser explicitement les arguments de template :

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
21
22
23
 
#include <iostream>
#include <type_traits>
 
template<class T, std::enable_if_t<std::is_pointer_v<std::remove_reference_t<T>>, int> = 0>
void pointer_or_array(T&& param)
{
	std::cout << std::forward<T>(param) << " size: ?" << std::endl;
}
 
template<class T, std::enable_if_t<std::is_array_v<std::remove_reference_t<T>>, int> = 0>
void pointer_or_array(T&& param)
{
	std::cout << std::forward<T>(param) << " size: " << std::extent<std::remove_reference_t<T>>::value << std::endl;
}
 
int main()
{
	pointer_or_array("abc");
	char const* abc = "abc";
	pointer_or_array(abc);
	return 0;
}

Vivement les concepts du C++20 ! Ces dernier permettront d'éviter les std::enable_if_t.

[camboui]

Pyramidev, bravo

Plus difficile maintenant, j'aimerais surcharger l'operator+() de basic_string pour lui ajouter le cas du paramètre array:

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
template<class Chr, class Tr, class Al, size_t Rswz>
inline basic_string<Chr, Tr, Al> operator+(
	basic_string<Chr, Tr, Al> const & ls,
	Chr const (&rs)[Rswz])
{
	basic_string<Chr, Tr, Al> s;
	s.reserve(ls.size() + Rswz - 1);
	return s.append(ls).append(rs, Rswz - 1);
}
 
template<class Chr, class Tr, class Al, size_t Rswz>
inline basic_string<Chr, Tr, Al> operator+(
	basic_string<Chr, Tr, Al> && ls,
	Chr const (&rs)[Rswz])
{
	return std::move(ls.append(rs, Rswz - 1));
}

Malheureusement le truc du enable_if is_pointer ne fonctionnera peut-être pas s'il n'est pas prévu par ceux qui ont écrit les sources de la STL...

C'est le WE, j'y réflérirais la semaine prochaine

Merci à tous et bon wékenne

[camboui]

Bonjour en ce joli samedi,
La nuit a porté conseil et m'apporté ceci

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
template<class T, std::enable_if_t<std::is_pointer_v<T>, int> = 0>
void pointer_or_array(T param)
{
	std::cout << param << " size: ?" << std::endl;
}
 
template<class T, size_t S>
void pointer_or_array(T const (&param)[S])
{
	std::cout << param << " size: " << S << std::endl;
}
 
int main()
{
	pointer_or_array("abc");
	char const *abc = "abc";
	pointer_or_array(abc);
	return 0;
]

Le code est plus simple et plus lisible, et aussi plus performant.
Ici le pointeur est passé par valeur, tel quel. Dans le code de Pyramidev il est passé par référence (pour peu que j'ai bien pu juger le code en Release et optmisé de Visual Studio 2017).

[Médinoc]

Aussi dans le code de pyramidev, si la fonction prend une rvalue reference en paramètre, cela ne change-t-il pas son contrat? (notamment dans le cas du pointeur, il pourrait être changé par la fonction)