template-specialization

I want to write an unmarshaller to extract arguments stored in a msgpack array for individual arguments to a call of sigc::signal::emit(...) . I tried this: template<class... T> class MsgpackAdapter: public MsgpackAdapterBase { public: MsgpackAdapter (sigc::signal<void, T...> &sig) : MsgpackAdapterBase (), signal_ (sig) {} protected: virtual void do_emit (const msgpack::object_array &mp_args) override; private: sigc::signal<void, T...> signal_; }; template<class T1> void MsgpackAdapter<T1>::do_emit (const msgpack::object_array &mp_args) { T1 a1; mp_args.ptr[0].convert (a1); signal_.emit (a1);

I have the following simple strinToTypeImpl function which converts any kind of string into the template type. The problem I am concerned about is the fact that the compiler tells me for the partial specialization for typename MyMatrix<T>::Vector3 : template parameter T not used in partial specialization Can't I use dependent names in the specialization? namespace details { template<typename T> struct stringToTypeImpl{ bool operator()(T& t, const std::string& s) { std::istringstream iss(s); return !(iss >> t).fail(); } }; template<typename T> struct stringToTypeImpl< typename MyMatrix<T>:

This is a followup to C++ templates: prevent instantiation of base template I use templates to achieve function overloading without the mess of implicit type conversions: declare the function template, define desired specializations (overloads). all is well except wrong code does not produce errors until the link phase: lib.hpp: template<class T> T f(T v); lib.cpp: #include "lib.hpp" template<> long f(long v) { return -v; } template<> bool f(bool v) { return !v; } main.cpp: #include <iostream> #include "lib.hpp" int main() { std::cout << f(123L) << ", " << f(true) << ", " << f(234) << "\n" ; }

Why is the following code invalid? template <typename S, typename T> struct B{ void f(T t, S s) {t.f<S>(s); } }; gcc 4.3.4 complains that it "expected primary-expression before '>' token", i.e. that "S" wasn't a valid primary-expression. You need to specify that f is a template: void f(T t, S s) { t.template f<S>(s); } C++ doesn’t know this (at this point) since f ’s type depends on the type of the template parameter T . Furthermore, the following syntax would be ambiguous: does < mean the start of a template list or a less-than operator? To help C++ figure that out you need to specify that f

Following code generate no compilation/linker error/warning: // A.h #include<iostream> struct A { template<typename T> static void foo (T t) { std::cout << "A::foo(T)\n"; } }; void other (); // main.cpp #include"A.h" int main () { A::foo(4.7); other(); } // other.cpp #include"A.h" template<> void A::foo (double d) { cout << "A::foo(double)\n"; } int other () { A::foo(4.7); } The output surprisingly is: A::foo(T) A::foo(double) Why compiler is not able to pick up the correct A::foo(double) in case of main.cpp ? Agree that, there is no issue as expected, if there is a declaration in A.h like