Discussion :

[Bktero]

Hello,

Par un jeu un peu étonnant, je suis arrivé à un code comme ceci :

Code :

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

1
2
3
4
5
template<typename T>
class assert_type_not_copyable {
	static_assert(not std::is_copy_constructible<T>(), "Error! Type should not be copy constructible");
	static_assert(not std::is_copy_assignable<T>(), "Error! Type should not be copy assignable");
};

Ca fait bien le taff :

Code :

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

1
2
3
4
5
6
7
8
class OK {
	OK(const OK&) = delete;
	OK& operator=(const OK&) = delete;
};
 
int main() {
	assert_type_not_copyable<OK>();
}

Mon interrogation vient du fait que je dois mettre les parenthèses lors de l'utilisation, comme ci on appelait la classe. Il se passe quoi en fait ?

Merci d'avance

[Bousk]

Salut,

la parenthèse instancier l'objet puis l'opérateur bool sera utilisé pour convertir en machin testable.
Mais en général ces trucs se manipulent plutôt via leur membre static value.
Le résultat est identique de toutes façons, c'est juste de la préférence d'écriture.

http://www.cplusplus.com/reference/t...constructible/
http://www.cplusplus.com/reference/t...%20value_type/

[Pyramidev]

Salut,

std::is_copy_constructible<T>() crée un objet de type std::is_copy_constructible<T> en appelant le constructeur par défaut. On aurait pu aussi l'écrire std::is_copy_constructible<T>{}.
not est un synonyme de !, donc not std::is_copy_constructible<T>() signifie !std::is_copy_constructible<T>{}. Le compilateur fait une conversion en booléen en appelant la fonction membre operator bool de la classe std::is_copy_constructible<T>.

Avant le C++17, on écrivait plutôt std::is_copy_constructible<T>::value. Depuis le C++17, on écrit plutôt std::is_copy_constructible_v<T>.

Attention, si tu utilises un std::is_copy_constructible dans un static_assert en attendant les concepts du C++20, alors il y a peut-être un problème dans ton code. Les classes de <type_traits> sont insidieuses.

Voici un bout de code qui illustre le problème :

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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
 
template<class T>
class Test1 {
private:
	T m_member;
public:
	template<class U>
	Test1& operator=(U&& arg) {
		static_assert(std::is_assignable_v<T&, U&&>);
		m_member = std::forward<U>(arg);
		return *this;
	}
};
 
template<class T>
class Test2 {
private:
	T m_member;
public:
	template<class U, std::enable_if_t<std::is_assignable_v<T&, U&&>, int> = 0>
	Test2& operator=(U&& arg) {
		m_member = std::forward<U>(arg);
		return *this;
	}
};
 
int main()
{
	std::cout
		<< "std::is_assignable_v<Test1<int>&, std::string> : "
		<< (std::is_assignable_v<Test1<int>&, std::string> ? "true" : "false") << ".\n"
		<< "std::is_assignable_v<Test2<int>&, std::string> : "
		<< (std::is_assignable_v<Test2<int>&, std::string> ? "true" : "false") << ".\n";
	return 0;
}

La sortie est :

Code :

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

1
2
std::is_assignable_v<Test1<int>, std::string> : true.
std::is_assignable_v<Test2<int>, std::string> : false.

Si tu essaies d'affecter un std::string à un Test1<int>& ou à un Test2<int>&, tu auras une erreur de compilation.
Et pourtant, std::is_assignable_v<Test1<int>&, std::string> retourne true.
Par contre, std::is_assignable_v<Test2<int>&, std::string> retourne bien false.

[Bktero]

std::is_copy_constructible<T>() crée un objet de type std::is_copy_constructible<T> en appelant le constructeur par défaut.

Ça parait évident une fois dit comme ça...

Merci pour vos réponses !