CODEWITHSUNDEEP
c++templates
Chris Vig
Chris Vig

Reputation: 8802

Reason for using non-type template parameter instead of regular parameter?

In C++ you can create templates using a non-type template parameter like this:

template< int I >
void add( int& value )
{
  value += I;
}

int main( int argc, char** argv )
{
  int i = 10;
  add< 5 >( i );
  std::cout << i << std::endl;
}

Which prints "15" to cout. What is the use for this? Is there any reason for using a non-type template parameter instead of something more conventional like:

void add( int& value, int amount )
{
  value += amount;
}

Sorry if this has already been asked (I looked but couldn't find anything).

Upvotes: 37

Views: 8438

Answers (6)

templatetypedef
templatetypedef

Reputation: 373312

There are many applications for non-type template arguments; here are a few:

You can use non-type arguments to implement generic types representing fixed-sized arrays or matrices. For example, you might parameterize a Matrix type over its dimensions, so you could make a Matrix<4, 3> or a Matrix<2, 2>. If you then define overloaded operators for these types correctly, you can prevent accidental errors from adding or multiplying matrices of incorrect dimensions, and can make functions that explicitly communicate the expected dimensions of the matrices they accept. This prevents a huge class of runtime errors from occur by detecting the violations at compile-time.

You can use non-type arguments to implement compile-time function evaluation through template metaprogramming. For example, here's a simple template that computes factorial at compile-time:

template <unsigned n> struct Factorial {
    enum { 
       result = n * Factorial<n - 1>::result
    };
};
template <> struct Factorial<0> {
    enum {
       result = 1
    };
};

This allows you to write code like Factorial<10>::result to obtain, at compile-time, the value of 10!. This can prevent extra code execution at runtime.

Additionally, you can use non-type arguments to implement compile-time dimensional analysis, which allows you to define types for kilograms, meters, seconds, etc. such that the compiler can ensure that you don't accidentally use kilograms where you meant meters, etc.

Hope this helps!

Upvotes: 31

AnT stands with Russia
AnT stands with Russia

Reputation: 320729

Well, this the typical choice between compile-time polymorphism and run-time polymorphism.

From the wording of your question in appears that you see nothing unusual in "ordinary" template parameters, while perceiving non-type parameters as something strange and/or redundant. In reality the same issue can be applied to template type parameters (what you called "ordinary" parameters) as well. Identical functionality can often be implemented either through polymorphic classes with virtual functions (run-time polymorphism) or through template type parameters (compile-time polymorphism). One can also ask why we need template type parameters, since virtually everything can be implemented using polymorphic classes.

In case of non-type parameters, you might want to have something like this one day

template <int N> void foo(char (&array)[N]) {
  ...
}

which cannot be implemented with a run-time value.

Upvotes: 8

Seth Carnegie
Seth Carnegie

Reputation: 75150

In that particular instance, there's not really any advantage. But using template parameters like that, you can do a lot of things you couldn't do otherwise, like effectively bind variables to functions (like boost::bind), specify the size of a compile-time array in a function or class (std::array being a ready example of that), etc.

For instance, with that function, you write a function like

template<typename T>
void apply(T f) {
    f(somenum);
}

Then you can pass apply a function:

apply(&add<23>);

That's an extremely simple example, but it demonstrates the principle. More advanced applications include applying functions to every value in a collection, calculating things like the factorial of a function at compile time, and more.

You couldn't do any of that any other way.

Upvotes: 5

Kerrek SB
Kerrek SB

Reputation: 477552

The most frequent use for a value parameter that I can think of is std::get<N>, which retrieves the Nth element of a std::tuple<Args...>. The second-most frequent use would be std::integral_constant and its main derivatives std::true_type and std::false_type, which are ubiquitous in any sort of trait classes. In fact, type traits are absolutely replete with value template parameters. In particular, there are SFINAE techniques which leverage a template of signature <typename T, T> to check for the existence of a class member.

Upvotes: 1

Clinton
Clinton

Reputation: 23135

You're probably right in this case, but there are cases where you need to know this information at compile time:

But how about this?

template <std::size_t N>
std::array<int, N> get_array() { ... }

std::array needs to know its size at compile time (as it is allocated on the stack).

You can't do something like this:

std::array<int>(5);

Upvotes: 7

K-ballo
K-ballo

Reputation: 81399

There are lots of reasons, like doing template metaprogramming (check Boost.MPL). But there is no need to go that far, C++11's std::tuple has an accessor std::get<i> that needs to be indexed at compile time, since the result is dependent on the index.

Upvotes: 1

Related Questions