Typename vs Class in Template Declarations

The class keyword was introduced in the original C++ template syntax, and was Initially used for all template type parameters.

The typename keyword was introduced later to clarify that the template parameter could be any type, not just a class.

In template parameter declarations, typename and class are often interchangeable, but there are some subtle differences and historical reasons for their usage Let's explore the differences and when to use each.

In most cases, typename and class can be used interchangeably in template parameter declarations. However, there are a few key differences:

Semantics

• class implies that the type parameter should be a class or struct.
• typename more accurately conveys that the parameter can be any type, including fundamental types, pointers, or classes.

Template Template Parameters

• When declaring a template template parameter, you must use class (before C++17).
• From C++17 onwards, both class and typename are allowed.

Dependent Names

• typename is required when referring to a dependent type name inside a template (not in the parameter list).

Here's an example illustrating these points:

1#include <iostream>
2#include <vector>
3
4// These are equivalent
5template <typename T>
6void func1(T t) {
7  std::cout << t << '\n';
8}
9
10template <class T>
11void func2(T t) {
12  std::cout << t << '\n';
13}
14
15// Template template parameter (pre-C++17)
16template <template <class> class Container>
17void func3(Container<int>& c) {
18  std::cout << "Container size: "
19    << c.size() << '\n';
20}
21
22// Dependent type name
23template <typename T>
24void func4() {
25  // 'typename' required here
26  typename T::value_type val;
27  std::cout << "Type size: "
28    << sizeof(val) << '\n';
29}
30
31int main() {
32  func1(42);
33  func2("Hello");
34
35  std::vector<int> vec = {1, 2, 3};
36  func3(vec);
37
38  func4<std::vector<double>>();
39}

142
2Hello
3Container size: 3
4Type size: 8

While typename and class are often interchangeable, there are some guidelines for their usage:

Prefer typename for General Type Parameters

It's more accurate and doesn't imply that the type must be a class.

1template<typename T>
2void func(T t) {/* ... */ }

Pre-C++17

Use class for template template parameters if targeting pre-C++17

1template<template<class> class Container>
2void func(Container<int>& c) {/* ... */}

Dependent Type Names

Always use typename for dependent type names within a template

1template<typename T>
2void func() {
3  typename T::value_type val;
4  // ...
5}

Be Consistent Within Your Codebase

• If your project has a style guide, follow it.
• If you're working on existing code, match the existing style.

Consider Readability

In some cases, class might be more readable, especially when working with class-like concepts.

In modern C++, typename is generally preferred for its clarity and accuracy. However, both keywords remain in use, and understanding their subtle differences can help you write more expressive and correct template code.