function-templates

Consider this function template: template<typename T> unsigned long f(void *) { return 0;} Now, I print the addresses of f<A> and f<B> as: std::cout << (void*)f<A> << std::endl; std::cout << (void*)f<B> << std::endl; Why do they print the same address if compiled in MSVS10? Are they not two different functions and therefore should print different addresses? Updated: I realized that on ideone, it prints the different address. MSVS10 optimizes the code, as the function doesn't depend on T in any way, so it produces same function. @Mark's answer and comments on this are valuable. :-) Mark Ransom

Suppose I have a template function: template<typename T> T produce_5_function() { return T(5); } How can I pass this entire template to another template ? If produce_5_function was a functor, there would be no problem: template<typename T> struct produce_5_functor { T operator()() const { return T(5); } }; template<template<typename T>class F> struct client_template { int operator()() const { return F<int>()(); } }; int five = client_template< produce_5_functor >()(); but I want to be able to do this with a raw function template: template<??? F> struct client_template { int operator()() const

I am wondering why the following code doesn't compile: struct S { template <typename... T> S(T..., int); }; S c{0, 0}; This code fails to compile with both clang and GCC 4.8. Here is the error with clang: test.cpp:7:3: error: no matching constructor for initialization of 'S' S c{0, 0}; ^~~~~~~ test.cpp:4:5: note: candidate constructor not viable: requires 1 argument, but 2 were provided S(T..., int); ^ It seems to me that this should work, and T should be deduced to be a pack of length 1. If the standards forbids doing things like this, does anyone know why? Because when a function parameter

I know the language specification forbids partial specialization of function template. I would like to know the rationale why it forbids it? Are they not useful? template<typename T, typename U> void f() {} //allowed! template<> void f<int, char>() {} //allowed! template<typename T> void f<char, T>() {} //not allowed! template<typename T> void f<T, int>() {} //not allowed! Cheers and hth. - Alf AFAIK that's changed in C++0x. I guess it was just an oversight (considering that you can always get the partial specialization effect with more verbose code, by placing the function as a static member