Function signature-like expressions as C++ template arguments

by

With regards to your first question – about the type int(char, float) – this is a valid C++ type and is the type of a function that takes in a char and a float and returns an int. Note that this is the type of the actual function, not a function pointer, which would be an int (*) (char, float). The actual type of any function is this unusual type. For example, the type of

void DoSomething() {
    /* ... */
}

is void ().

The reason that this doesn’t come up much during routine programming is that in most circumstances you can’t declare variables of this type. For example, this code is illegal:

void MyFunction() { 
    void function() = DoSomething; // Error!
}

However, one case where you do actually see function types used is for passing function pointers around:

void MyFunction(void FunctionArgument()) {
     /* ... */
}

It’s more common to see this sort of function written to take in a function pointer, but it’s perfectly fine to take in the function itself. It gets casted behind-the-scenes.

As for your second question, why it’s illegal to have the same template written with different numbers of arguments, I don’t know the exactly wording in the spec that prohibits it, but it has something to do with the fact that once you’ve declared a class template, you can’t change the number of arguments to it. However, you can provide a partial specialization over that template that has a different number of arguments, provided of course that the partial specialization only specializes over the original number of arguments. For example:

template <typename T> class Function;
template <typename Arg, typename Ret> class Function<Ret (Arg)> { 
    /* ... */
};

Here, Function always takes one parameter. The template specialization takes in two arguments, but the specialization is still only over one type (specifically, Ret (Arg)).

More Related Contents:

  1. C++ pointer decleration
  2. Storing C++ template function definitions in a .CPP file
  3. std::enable_if to conditionally compile a member function
  4. Does it make any sense to use inline keyword with templates?
  5. explicit specialization of template class member function
  6. Metaprograming: Failure of Function Definition Defines a Separate Function
  7. Template specialization of particular members?
  8. c++ template partial specialization member function [duplicate]
  9. What is the partial ordering procedure in template deduction
  10. Templates polymorphism
  11. A better way to avoid public member invisibility and source code bloat/repetition with inherited class templates?
  12. Default template arguments for function templates
  13. C++11: I can go from multiple args to tuple, but can I go from tuple to multiple args? [duplicate]
  14. Why can’t the compiler deduce the template type from default arguments?
  15. How to cin values into a vector
  16. How to detect existence of a class using SFINAE?
  17. C++ template copy constructor on template class
  18. Template function as a template argument
  19. What does this variadic template code do?
  20. SFINAE works differently in cases of type and non-type template parameters
  21. Making a template parameter a friend?
  22. Can the point-of-instantiation be delayed until the end of the translation unit?
  23. How do I export templated classes from a dll without explicit specification?
  24. How to write `is_complete` template?
  25. How to pass a template function in a template argument list
  26. c++ automatic factory registration of derived types
  27. access private member using template trick
  28. How to check if a template parameter is an iterator type or not?
  29. Will I be able to declare a constexpr lambda inside a template parameter?
  30. C++ template function default value

Leave a Comment