Constraining Class Templates

Yes, you can use concepts to constrain class templates, similar to how you constrain function templates. Here's an example:

1#include <concepts>
2#include <iostream>
3
4template <typename T>
5concept Printable = requires(T obj) {
6  { obj.Print() } -> std::same_as<void>;
7};
8
9template <Printable T>
10class Logger {
11 public:
12  void Log(const T& obj) { obj.Print(); }
13};
14
15struct MyClass {
16  void Print() const {
17    std::cout << "Hello World";
18  }
19};
20
21int main() {
22  Logger<MyClass> logger;
23  MyClass obj;
24  logger.Log(obj);
25}

1Hello World

In this example, the Printable concept requires a type T to have a Print() member function that returns void.

The Logger class template is constrained using the Printable concept, specifying that the template parameter T must satisfy the concept's requirements.

Inside the Logger class, the Log member function accepts an object of type T and calls its Print() function.

The MyClass struct satisfies the Printable concept by providing the required Print() member function.

In the main function, we can create an instance of Logger<MyClass> because MyClass meets the Printable concept's requirements. We can then use the Log member function to log an object of MyClass.

By constraining class templates with concepts, we ensure that the class can only be instantiated with types that fulfill the specified requirements. This helps catch errors at compile-time and provides better documentation and clarity about the expectations of the class template.