**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** Templates and Generic Programming **Topic:** Implement a generic data structure using templates and C++20 concepts.(Lab topic) In this lab, we will implement a generic data structure using templates and C++20 concepts. The goal is to create a stack data structure that can store elements of any type, while ensuring type safety and efficiency. **What You Will Learn:** * Creating a generic stack class using templates * Using C++20 concepts to constrain template parameters * Implementing stack operations (push, pop, top, empty) * Using `std::string` and `int` as example types **Getting Started:** Before you begin, make sure you have a good understanding of the following concepts: * Templates (function and class templates) * Template specialization and overloading * Variadic templates and fold expressions * Concepts in C++20 If you need a refresher, refer to the previous sections on Templates and Generic Programming. **Implementing the Generic Stack Class:** ```cpp // stack.h #ifndef STACK_H #define STACK_H #include <concepts> #include <utility> template <typename T> requires std::constructible<T> && std::movable<T> && std::copyable<T> class Stack { private: struct Node { T data; Node* next; Node(const T& data) : data(data), next(nullptr) {} }; Node* top_; size_t size_; public: Stack() : top_(nullptr), size_(0) {} ~Stack() { while (top_) { Node* next = top_->next; delete top_; top_ = next; } } void push(const T& value) { Node* new_node = new Node(value); new_node->next = top_; top_ = new_node; size_++; } void pop() { if (empty()) { throw std::runtime_error("Stack is empty"); } Node* next = top_->next; delete top_; top_ = next; size_--; } const T& top() const { if (empty()) { throw std::runtime_error("Stack is empty"); } return top_->data; } bool empty() const { return top_ == nullptr; } size_t size() const { return size_; } }; #endif // STACK_H ``` In this implementation, we use a linked list to store the elements of the stack. The `Stack` class template takes a type parameter `T` that represents the type of elements stored in the stack. We use C++20 concepts to constrain the template parameter `T`. Specifically, we require `T` to be constructible, movable, and copyable. This ensures that the stack can store elements of any type that supports these operations. The `push` operation adds a new element to the top of the stack, while the `pop` operation removes the top element. The `top` operation returns a reference to the top element, and the `empty` operation checks whether the stack is empty. **Using the Generic Stack Class:** ```cpp // main.cpp #include "stack.h" #include <iostream> #include <string> int main() { // Create a stack of integers Stack<int> intStack; intStack.push(1); intStack.push(2); intStack.push(3); std::cout << "Top element: " << intStack.top() << std::endl; std::cout << "Stack size: " << intStack.size() << std::endl; intStack.pop(); std::cout << "Top element: " << intStack.top() << std::endl; std::cout << "Stack size: " << intStack.size() << std::endl; // Create a stack of strings Stack<std::string> stringStack; stringStack.push("Hello"); stringStack.push("World"); std::cout << "Top element: " << stringStack.top() << std::endl; std::cout << "Stack size: " << stringStack.size() << std::endl; return 0; } ``` In this example, we create a stack of integers and a stack of strings, and demonstrate the `push`, `pop`, `top`, and `empty` operations. **Conclusion:** In this lab, we implemented a generic stack class using templates and C++20 concepts. We used concepts to constrain the template parameter and ensure type safety. We also demonstrated the use of the stack class with different types, including integers and strings. **Practical Takeaways:** * Use templates to create generic data structures that can store elements of any type * Use C++20 concepts to constrain template parameters and ensure type safety * Implement stack operations (push, pop, top, empty) to manipulate the stack * Use `std::string` and `int` as example types to demonstrate the generic stack class **What's Next:** In the next topic, we will explore dynamic memory allocation using `new`, `delete`, `malloc`, and `free`. We will learn how to allocate memory at runtime and manage resources effectively. **External Resources:** * [C++20 Concepts (cppreference.com)](https://en.cppreference.com/w/cpp/concepts) * [Template Metaprogramming (cppreference.com)](https://en.cppreference.com/w/cpp/metaprogramming) **Leave a Comment/Ask for Help:** If you have any questions or need further clarification on any of the concepts covered in this topic, please leave a comment below. We will be happy to help.