Différences

Ci-dessous, les différences entre deux révisions de la page.

--- lang:cpp:templatespecialisation [2021/05/13 13:23] – [Il faut commencer par spécialiser le premier template] root
+++ lang:cpp:templatespecialisation [2021/07/05 09:51] (Version actuelle) – Déplacement de Divers en bas root
@@ Ligne 1: / Ligne 1: @@
-====Divers====
-===Empêcher l'utilisation du template non spécialisé===
-''static_assert(false)'' ne peut être utilisé directement car il est systématiquement évalué par le compilateur. Il faut feinter...
-<code cpp>
-#include <type_traits>
-template <typename T>
-struct foobar : std::false_type {};
-// Template général.
-template <class T>
-T fun(T a) {
-  static_assert(foobar<T>::value,
-                "this function has to be implemented for desired type");
-}
-template <>
-int fun(int a) {
-  return a;
-}
-int main() {
-  // fun<char>('a'); // Echec
-  fun<int>(10);
-  // fun<float>(10.14); // Echec
-}
-</code>
 ====Spécialisation partielle====
@@ Ligne 361: / Ligne 330: @@
 [[https://stackoverflow.com/questions/6674795/how-to-call-generic-template-function-in-a-specialization-version|How to call generic template function in a specialization version]] {{ :lang:cpp:template:c_-_how_to_call_generic_template_function_in_a_specialization_version_-_stack_overflow_2020-02-06_23_35_03_.html |Archive du 13/07/2011 le 06/02/2020}}
+====Divers====
+===Empêcher l'utilisation du template non spécialisé===
+''static_assert(false)'' ne peut être utilisé directement car il est systématiquement évalué par le compilateur. Il faut ajouter un niveau d'indirection.
+<code cpp>
+#include <type_traits>
+template <typename T>
+struct foobar : std::false_type {};
+// Template général.
+template <class T>
+T fun(T a) {
+  // La variable value n'est évaluée que si la méthode est utilisée.
+  static_assert(foobar<T>::value,
+                "this function has to be implemented for desired type");
+}
+template <>
+int fun(int a) {
+  return a;
+}
+int main() {
+  // fun<char>('a'); // Echec
+  fun<int>(10);
+  // fun<float>(10.14); // Echec
+}
+</code>
+Autre exemple avec ''std::conditional'':
+<code cpp>
+#include <type_traits>
+struct A
+{
+  using Ty = int;
+};
+struct B {};
+// KO, should be OK.
+// using Ttrue = std::conditional_t<true, A::Ty, B::Ty>;
+// KO
+// using Tfalse = std::conditional_t<false, A::Ty, B::Ty>;
+template <typename T>
+struct LazyLoadIdentity
+{
+  using type = T;
+};
+template <typename T>
+struct LazyLoadTy : LazyLoadIdentity<typename T::Ty> {};
+// OK
+using Ttrue = std::conditional_t<true, LazyLoadTy<A>, LazyLoadTy<B>>::type;
+// KO
+//using Tfalse = std::conditional_t<false, LazyLoadTy<A>, LazyLoadTy<B>>::type;
+</code>
+[[https://stackoverflow.com/questions/34281017/is-it-possible-to-build-a-lazy-conditional-metafunction|Is it possible to build a lazy conditional metafunction]] {{ :lang:cpp:template:c_-_is_it_possible_to_build_a_lazy_conditional_metafunction_-_stack_overflow_2021-05-17_22_08_45_.html |Archive du 15/12/2015 le 17/05/2021}}