template-specialization

问题 If I have a header foo.h which I include all over my project, it seems to work fine when all it contains is: template<typename T> void foo(const T param) { cout << param << endl; } But I get one definition rule (ODR) errors when I add a specalization to foo.h: template<> void foo(const bool param) { cout << param << endl; } Obviously I can solve this by inline 'ing the specialization. My question is, why do I need to? If the template doesn't violate ODR, why does a specialization? 回答1: An

问题 (This question is a branch-out from the discussion in the comments of Template specialization of variable template and type deduction.) [temp.expl.spec]/10 states that [ emphasis mine]: A trailing template-argument can be left unspecified in the template-id naming an explicit function template specialization provided it can be deduced from the function argument type . [ Example: template<class T> class Array { /* ... */ }; template<class T> void sort(Array<T>& v); // explicit specialization

问题 I have a Matrix class template as follows: template<typename T, std::size_t nrows, std::size_t ncols> class Matrix { T data[nrows][ncols]; public: T& operator ()(std::size_t i, std::size_t j) { return data[i][j]; } }; What I want is to define a .setIdentity() function only for instantiations when nrows==ncols is true at compile time. And there will be no definition of .setIdentity() when nrows==ncols is false . What I am trying is using enable_if idiom, but that will define the function for

问题 I was doing some tests with the following C++20 code (built with current GCC10): template <typename ToT, typename FromT> ToT myfunction(const FromT& pFrom) = delete; template <typename ToT, typename FromT> struct myclass { inline ToT myclassmethod(const FromT& pFrom) { return myfunction<ToT, FromT>(pFrom); } }; /* C++20 concepts code */ template <std::same_as<std::string> ToT, std::integral FromT> inline ToT myfunction(const FromT& pFrom) { return std::to_string(pFrom); } template <std::same

问题 I was doing some tests with the following C++20 code (built with current GCC10): template <typename ToT, typename FromT> ToT myfunction(const FromT& pFrom) = delete; template <typename ToT, typename FromT> struct myclass { inline ToT myclassmethod(const FromT& pFrom) { return myfunction<ToT, FromT>(pFrom); } }; /* C++20 concepts code */ template <std::same_as<std::string> ToT, std::integral FromT> inline ToT myfunction(const FromT& pFrom) { return std::to_string(pFrom); } template <std::same

问题 I have some classes which can be checked. The code which implements this declares a function template in a header file and specializes it in different source files: // check.h template <class T> bool check(const T& object); // class1.h struct Class1 {int mass;}; // check_class1.cpp #include "class1.h" #include "check.h" template <> bool check(const Class1& object) {return object.mass < 100;} // class2.h struct Class2 {int price;}; // check_class2.cpp #include "class2.h" #include "check.h"

问题 template <class C> C fnc(); template <> int fnc(){return 0;} template <class C> C var; template <> int var = 0; // compile error int main() { } There's a specialization of a fnc function declared without an explicit type indication (such as int fnc<int>() ), so the type of template argument is deduced from the function return type, but that thing does not work for variable templates (it leads to compiler error). Is this a correct behavior or a bug in all compilers a have tested (clang, gcc)?

问题 template <class C> C fnc(); template <> int fnc(){return 0;} template <class C> C var; template <> int var = 0; // compile error int main() { } There's a specialization of a fnc function declared without an explicit type indication (such as int fnc<int>() ), so the type of template argument is deduced from the function return type, but that thing does not work for variable templates (it leads to compiler error). Is this a correct behavior or a bug in all compilers a have tested (clang, gcc)?

问题 I know that the question has been asked several times and I've been reading posts like: Initializing static members of a templated class How can I Declare/define/initialize a static member variable of template classes as static member variables of a class? static member initialization for specialized template class However, I'm still struggling putting together all the pieces about templates, specializations, static data members definition and declarations. What I have is something like:

问题 I have a function template with integer template parameter. I would like to provide an implementation for particular integers only. An attempt to use the function template with another argument should cause a compilation error. I used static_assert in a way presented below. #include <type_traits> #include <iostream> template <typename T> struct false_type : public std::false_type {}; template <int T> void function() { static_assert(false_type<decltype(T)>::value, "Error"); }; template <> void