C++ Template Parameters: class vs typename

In a normal C++ type template parameter, class and typename mean exactly the same thing. Either keyword can introduce a parameter that will represent a type. The choice is usually a matter of team style and readability. However, typename has another important use in C++: telling the compiler that a dependent qualified name is a type.

A template lets you write code that works with many types. For example, a Box<T> can store an int, a std::string, or a custom type.

When declaring a type template parameter, C++ accepts either of these declarations:

template <class T>
class Box;

// Equivalent:
template <typename T>
class Box;

In this position, class does not mean that T must be a class. T may be any type, including fundamental types such as int, pointer types, enums, or class types.

template <class T>
class Box {
public:
    T value;
};

Box<int> number{42};
Box<double> price{19.99};

So, for ordinary type parameters, neither keyword provides extra capability. Consistency within a project is usually the best reason to choose one.

Think of a template parameter as a blank label on a box:

template <class T>

and

template <typename T>

both mean: “Create a blank label named T; later, someone will fill it with a type.” The two labels do the same job.

The word typename has a second job in template code. Imagine the compiler sees T::item. Until it knows what T is, it cannot tell whether item is a type or a value. Writing typename T::item is like attaching a note that says: “Treat item as a type.”

A type parameter can be declared with either keyword.

#include <iostream>

// `class` and `typename` are equivalent here.
template <class T>
T larger(T left, T right) {
    return left > right ? left : right;
}

template <typename T>
class Holder {
public:
    explicit Holder(T initialValue) : value(initialValue) {}

    T get() const {
        return value;
    }

private:
    T value;
};

int main() {
    std::cout << larger(4, 9) << '\n';

    Holder<double> temperature(21.5);
    std::cout << temperature.get() << '\n';
}

larger uses class T, while uses . Both parameters stand for a type.

Consider this function template:

template <typename T>
T add(T left, T right) {
    return left + right;
}

int result = add(3, 4);

Execution and compilation happen as follows:

1. template <typename T> declares T as a placeholder for a type.

2. The call add(3, 4) supplies two int arguments.

3. The compiler deduces that T is int.

4. It produces an int version of the function conceptually equivalent to:

   int add(int left, int right) {
       return left + right;
   }
   

5. The function returns , which is stored in .

Type template parameters are common throughout C++ code:

• Containers: std::vector<T>, std::optional<T>, and std::unique_ptr<T> need a type to store or manage.
• Generic algorithms: A function can work with different number types, iterators, or user-defined objects.
• Serialization: A template can save and load objects of multiple supported types.
• Library wrappers: A Result<T> or Cache<T> type can expose the same interface for many value types.
• Traits and aliases: Template code often obtains a nested type such as Traits<T>::value_type, where dependent-name typename may be required.

For example, a generic API response wrapper may use either parameter keyword:

template <typename T>
struct ApiResponse {
    int statusCode;
    T data;
};

ApiResponse<std::string> response{200, "ok"};

In production code, the choice between class and typename in a type parameter is commonly governed by a style guide.

Common patterns include:

• Use typename for all type parameters because it makes the intent explicit: the parameter represents a type.
• Use class for type parameters because it is shorter and traditional in generic C++ code.
• Use class in template declarations but reserve typename for dependent qualified types, making the special disambiguation easier to notice.

For example, this generic validation function uses an early return and a dependent nested type:

#include <stdexcept>

template <class Container>
typename Container::value_type firstOrThrow(const Container& items) {
    if (items.empty()) {
        throw std::runtime_error("Container is empty");
    }

    return *items.begin();
}

class Container declares a type parameter. has the different job of identifying a dependent nested type.

Thinking class T accepts only classes

This is incorrect. It accepts any type.

template <class T>
T identity(T value) {
    return value;
}

int count = identity(10); // Valid: T is int

Expecting a behavioral difference in ordinary type parameters

These declarations are equivalent:

template <class T> void process(T value);
template <typename T> void process(T value);

Do not choose one expecting different overload resolution, generated code, or performance.

Forgetting typename for a dependent nested type

The following is typically ill-formed because the compiler does not know whether T::value_type is a type:

// Equivalent type parameter declarations
template <class T>
struct A {};

template <typename T>
struct B {};

• In a type template parameter, class and typename have the same meaning.
• class T does not restrict T to class types.
• Choose one based on your codebase's style guide.
• typename also disambiguates a dependent qualified type:

template <class T>
using Value = typename T::value_type;

• Do not use either keyword for a non-type parameter:

template <int N>
struct FixedSizeArray {};

• Historical note: before C++17, template template parameter inner type parameters required class, not .

Is template<class T> faster than template<typename T>?

No. They are equivalent for normal type template parameters and produce no performance difference.

Should I use class or typename in modern C++?

Either is correct. Follow the existing style of the project or team. Many developers prefer typename because it reads clearly as “this is a type.”

Does class T mean that T must be an object-oriented class?

No. T can be int, double, an enum, a pointer, a class, or another valid type.

Why does C++ sometimes require typename?

Inside a template, a name such as T::value_type depends on T. typename tells the compiler that this dependent name is a type.

Can I replace every typename with class?

No. They are interchangeable only when declaring a type template parameter. In , only performs the required disambiguation.

• Function templates — Generic functions use type parameters such as T.
• Class templates — Generic classes store or operate on a parameterized type.
• Template argument deduction — Explains how the compiler infers T from function arguments.
• Dependent names — Explains why typename T::member_type may be necessary.
• Nested types — Common source of dependent qualified types in generic code.
• Non-type template parameters — Parameters that represent compile-time values rather than types.
• Template template parameters — Parameters that accept templates, with historical class and typename syntax details.
• C++ concepts — Modern constraints that can restrict which types a template accepts.