Template Methods in Non-Template Classes

Creating a template method within a non-template class is a powerful feature in C++ that allows you to have generic functionality within a specific class.

This can be particularly useful when you want to provide flexibility for a single method without making the entire class a template.

Here's an example of how to create a template method in a non-template class:

1#include <iostream>
2#include <list>
3#include <vector>
4
5class DataProcessor {
6 public:
7  // Non-template method
8  void ProcessInt(int value) {
9    std::cout << "Processing int: "
10      << value << '\n';
11  }
12
13  // Template method
14  template <typename T>
15  void ProcessGeneric(const T& value) {
16    std::cout << "Processing generic value: "
17      << value << '\n';
18  }
19
20  // Template method with multiple parameters
21  template <typename T, typename Container>
22  void ProcessContainer(const Container& container) {
23    std::cout << "Processing container:\n";
24    for (const T& item : container) {
25      std::cout << "  " << item << '\n';
26    }
27  }
28};
29
30int main() {
31  DataProcessor processor;
32
33  // Using non-template method
34  processor.ProcessInt(42);
35
36  // Using template methods
37  processor.ProcessGeneric(3.14);
38  processor.ProcessGeneric("Hello");
39
40  std::vector<int> vec = {1, 2, 3, 4, 5};
41  processor.ProcessContainer<int>(vec);
42
43  std::list<std::string> list = {
44    "apple", "banana", "cherry"
45  };
46  processor.ProcessContainer<std::string>(list);
47}

1Processing int: 42
2Processing generic value: 3.14
3Processing generic value: Hello
4Processing container:
5  1
6  2
7  3
8  4
9  5
10Processing container:
11  apple
12  banana
13  cherry

In this example, DataProcessor is a non-template class, but it contains template methods. Here's what's happening:

1. ProcessInt is a regular, non-template method that works specifically with int.
2. ProcessGeneric is a template method that can work with any type. The type T is deduced from the argument passed to the method.
3. ProcessContainer is a more complex template method that takes two template parameters: the type of elements in the container (T) and the container type itself (Container).

When using template methods, you typically don't need to specify the template arguments explicitly - the compiler can deduce them from the function arguments.

However, in some cases (like with ProcessContainer), you might need to specify some of the template arguments explicitly if they can't be deduced.

Some key points to remember:

• Template methods must be defined in the header file, not in a separate .cpp file. This is because the compiler needs to see the full definition to generate the code for each instantiation.
• You can have both template and non-template methods in the same class.
• Template methods can coexist with regular methods that have the same name, participating in overload resolution.
• You can specialize template methods for specific types, similar to how you can specialize class templates.

Template methods in non-template classes provide a great way to add generic functionality to your classes without the need to make the entire class a template. This can lead to more flexible and reusable code.