Summary - Template basics

Combine template functions and classes to write a Stack<T>.

Summary - Templates

In this group you learned the basics of templates. A template writes type-independent code. A template function deduces the type at the call. A template class takes a type parameter. Multiple type parameters are comma-separated. Specialization provides a custom version for a specific type.

In the final task you will combine them: write an identity template and a Box template class, then construct a Box<int> instance with identity(42). This shows how templates compose.

Exercise Mini task: combine Box and identity

Write template <typename T> T identity(T x) that returns x. Write template <typename T> class Box with private T value, constructor Box(T v) : value(v) {}, T getValue() returning the value. In main write Box<int> b(identity(42)); and std::cout << b.getValue() << std::endl;.

Show example solution

#include <iostream>

template <typename T>
T identity(T x) { return x; }

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T getValue() { return value; }
};

int main() {
    Box<int> b(identity(42));
    std::cout << b.getValue() << std::endl;
    return 0;
}

Test yourself

What does template <typename T> declare?
```
template <typename T>
```
- A variable
- A type parameter
- A class
- A function
Show answer

A type parameter — template <typename T> declares a type parameter.
Template class instantiation
```
Box<____> b;
```
Show answer
```
Box<int> b;
```
Match the concepts

template <typename T>

General template
template <>

Full specialization
Box<int>

Class instantiation
identity(42)

Function call

Next lesson: std::vector

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies