Are you looking for Embedded Systems Course – Contact ETDA Experts

Embedded Tech Development Academy

Facebook Instagram Linkedin

9845870904

Template Classes in C++: Complete Technical Guide

Learn template classes in C++ with syntax, generic programming, stack implementation, multiple parameters, STL, concepts, and practical examples. Embedded Tech Development Academy (ETDA).

Table of Contents

Designing Template Classes in C++

Introduction

C++ is a powerful programming language that supports generic programming through templates. Templates allow developers to write reusable, flexible, and type-safe code that works with multiple data types without duplicating implementation logic. One of the most important applications of generic programming is the development of template classes, which enable developers to design generic data structures, containers, and reusable programming utilities.

Template classes are widely used in modern C++ libraries, particularly the Standard Template Library (STL), which provides containers such as vector, stack, map, and queue. Understanding template classes is essential for developing scalable software, efficient data structures, and maintainable applications. They are also useful in Embedded Systems programming, where reusable components can simplify firmware architecture and reduce code duplication across different data types.

At Embedded Tech Development Academy (ETDA), learners can strengthen their C++ programming fundamentals through technical learning and practical programming exercises. As a Top Embedded Training Institute in Bangalore, Embedded Tech Development Academy (ETDA) supports learners developing programming skills for Embedded Systems, Internet of Things (IoT), and firmware development, along with assured placement support for career preparation.

What Are Template Classes in C++?

A template class is a generic class that can operate with different data types using a template parameter. Instead of implementing separate classes for integers, floating-point numbers, and strings, developers can create a single class template.

Understanding Generic Programming

Generic programming focuses on writing algorithms and data structures independently of specific data types.

For example, a container class can store int, float, double, or string values by using a template parameter.

Basic Syntax of a Template Class 

template <typename T>
class Box {
    T data;

public:
    Box(T value) : data(value) {}

    void display() {
        std::cout << data << '\n';
    }
};

Here, T represents a generic type that is determined when an object is instantiated.

Template Parameter Declaration

typename and class can both declare type parameters in a template declaration.

Important Syntax Rule

A template declaration must appear before the class or function template definition. The template parameter is substituted with a specific type during template instantiation.

Advantages of Template Classes

Template classes provide several important advantages.

Code Reusability

Developers write a class once and reuse it with multiple types.

Type Safety

Templates preserve compile-time type checking and avoid many unsafe conversions associated with generic void* implementations.

Flexibility

Template classes support primitive data types, standard library types, and user-defined classes.

Maintainability

Reusable implementations reduce duplicated code and simplify software maintenance.

Example 1 – A Simple Template Class

The following program demonstrates a class that stores and displays different types of values.

C++ Program 

#include <iostream>
#include <string>

template <typename T>
class Play {
    T value;

public:
    Play(T val) : value(val) {}

    void display() {
        std::cout << "Value: "
                  << value << '\n';
    }
};

int main() {
    Play<int> intPlay(30);
    Play<double> doublePlay(3.14);
    Play<std::string> stringPlay("Hello India");

    intPlay.display();
    doublePlay.display();
    stringPlay.display();

    return 0;
}

Output:

Value: 30
Value: 3.14
Value: Hello India

The same class template generates different specializations for integer, double, and string types.

Example 2 – Designing a Template Stack Class

A stack is a linear data structure that follows the Last In, First Out (LIFO) principle. Template classes allow developers to implement stacks that support different data types.

Stack Implementation 

#include <iostream>
#include <string>

template <typename T>
class Stack {
    T arr[100];
    int top;

public:
    Stack() : top(-1) {}

    void push(const T& value) {
        if (top >= 99) {
            std::cout << "Stack Overflow!\n";
            return;
        }

        arr[++top] = value;
    }

    void pop() {
        if (top < 0) {
            std::cout << "Stack Underflow!\n";
            return;
        }

        std::cout << "Popped: "
                  << arr[top--] << '\n';
    }

    void peek() const {
        if (top >= 0)
            std::cout << "Top: "
                      << arr[top] << '\n';
        else
            std::cout << "Stack is empty!\n";
    }
};

Creating Different Stack Objects 

int main() {
    Stack<int> intStack;
    Stack<std::string> stringStack;

    intStack.push(10);
    intStack.push(20);
    intStack.peek();
    intStack.pop();

    stringStack.push("C++");
    stringStack.push("Templates");
    stringStack.peek();
    stringStack.pop();

    return 0;
}

Output:

Top: 20
Popped: 20
Top: Templates
Popped: Templates

Understanding Stack Operations

  • push() inserts an element.

  • pop() removes the top element.

  • peek() retrieves the top element without removing it.

  • top maintains the index of the current stack element.

Practical Implementation Consideration

This example uses a fixed-size array. Production implementations should consider dynamic storage, exception safety, and standard containers such as std::stack.

Example 3 – Template Classes with Multiple Parameters

C++ supports multiple template parameters within a single class template. This approach is useful for creating generic key-value structures and paired data objects.

Pair Class Implementation 

#include <iostream>
#include <string>

template <typename T1, typename T2>
class Pair {
    T1 first;
    T2 second;

public:
    Pair(T1 a, T2 b)
        : first(a), second(b) {}

    void display() const {
        std::cout << "Pair: ("
                  << first << ", "
                  << second << ")\n";
    }
};

int main() {
    Pair<int, std::string> p1(1, "One");
    Pair<std::string, double> p2("Pi", 3.14159);

    p1.display();
    p2.display();

    return 0;
}

Output:

Pair: (1, One)
Pair: (Pi, 3.14159)

Multiple template parameters allow each member to use a different data type.

Template Classes and STL

The Standard Template Library provides generic containers and algorithms implemented using templates.

Important STL Containers

ContainerPurpose
std::vectorDynamic array
std::stackLIFO container adaptor
std::queueFIFO container adaptor
std::mapSorted key-value container
std::pairStores two associated values

Why Use STL?

STL containers provide tested implementations with established interfaces and memory-management behavior. Developers should prefer standard containers when they satisfy application requirements rather than unnecessarily creating custom implementations.

Best Practices for Designing Template Classes

Use Meaningful Template Parameters

Names such as Key, Value, and Element improve readability in complex generic classes.

Avoid Unnecessary Template Instantiations

Each required specialization may generate additional machine code, potentially increasing binary size. This is important for memory-constrained Embedded Systems.

Use Modern C++ Concepts

C++20 Concepts allow template parameters to be constrained according to required operations.

#include <concepts>

template <std::integral T>
class Counter {
    T value;
};

This example restricts Counter to integral types.

Separate Interface and Implementation Carefully

Template definitions generally need to be visible at the point of instantiation. Therefore, template implementations are commonly placed in header files or included implementation files.

Applications of Template Classes in Embedded Systems and IoT

Template classes are useful in Embedded Systems for developing reusable firmware components.

Generic Data Buffers

A buffer template can manage sensor samples, integer counters, or communication data using a common implementation.

Communication Protocol Structures

Reusable template utilities can support data handling for UART, SPI, I2C, and CAN communication modules.

IoT Sensor Processing

Generic containers and utilities can simplify the handling of temperature, pressure, vibration, and other sensor measurements.

At Embedded Tech Development Academy (ETDA), learners develop programming knowledge relevant to Embedded Systems and Internet of Things (IoT) applications. Embedded Tech Development Academy (ETDA) provides technical learning and assured placement support for students preparing for embedded development opportunities.

Frequently Asked Questions

What is a template class in C++?

A template class is a generic class that supports multiple data types through template parameters.

Both can declare type parameters in template declarations. They are generally interchangeable in this context.

Template instantiation occurs when the compiler generates a specialization for a particular template argument.

Yes. Multiple template parameters allow a class to handle different types simultaneously.

They provide reusability, type safety, flexibility, and reduced code duplication.

Yes. They help create reusable firmware utilities, generic buffers, and data structures for Embedded Systems and Internet of Things (IoT) applications.

Conclusion

Template classes are an essential feature of modern C++ generic programming. They allow developers to design reusable, flexible, and type-safe data structures without implementing separate classes for every data type. By understanding template parameters, class instantiation, multiple template arguments, STL containers, and C++20 Concepts, programmers can develop maintainable and scalable software.

Template classes also have practical applications in Embedded Systems, firmware architecture, sensor data handling, communication protocols, and Internet of Things (IoT) development. However, developers should consider compilation complexity, binary size, memory requirements, and implementation constraints when designing templates for embedded hardware.

Embedded Tech Development Academy (ETDA) supports technical learning in C++, Embedded Systems, and Internet of Things (IoT) programming. As a Top Embedded Training Institute in Bangalore, Embedded Tech Development Academy (ETDA) emphasizes programming fundamentals, practical technical development, and assured placement support for aspiring embedded engineers.

Mastering template classes strengthens C++ programming skills and provides a foundation for developing efficient firmware components, reusable libraries, and industry-oriented Embedded Systems applications.

Author: ETDA Trainers
Experience: 10+ Years of Industry Experience in Embedded Systems, IoT, and Embedded C Programming

Home