[WIP] Add medium to hard C++ interview questions with detailed answers

[Copilot]

• Create 01-cpp-basics.md — C++ Basics (data types, pointers, references, memory management)
• Create 02-oop-concepts.md — OOP Concepts (classes, inheritance, polymorphism, encapsulation, abstraction)
• Create 03-stl.md — STL (vectors, maps, sets, iterators, algorithms)
• Create 04-templates-and-generics.md — Templates & Generic Programming
• Create 05-smart-pointers-and-modern-cpp.md — Smart Pointers & Modern C++ (C++11/14/17/20)
• Create 06-concurrency-and-multithreading.md — Concurrency & Multithreading
• Create 07-data-structures-and-algorithms.md — Data Structures & Algorithms
• Create 08-design-patterns.md — Design Patterns
• Create 09-common-coding-problems.md — Common Coding Problems
• Update README.md — Table of contents linking all files

Original prompt

Create a comprehensive set of medium to hard C++ interview preparation questions with detailed answers and push them as separate topic-wise .md files to the repository amolpawarap/cpp-preparation.

Requirements

Each topic should be its own .md file with 15-20 medium to hard level questions and detailed, well-explained answers including code examples where applicable.

Files to create:

1. 01-cpp-basics.md — C++ Basics (data types, pointers, references, memory management)

   • Cover: const correctness, pointer arithmetic, dangling pointers, memory leaks, stack vs heap, new/delete, malloc/free differences, reference vs pointer, volatile, sizeof operator, type casting (static_cast, dynamic_cast, reinterpret_cast, const_cast), undefined behavior, memory alignment, bitwise operations, lvalue vs rvalue.

2. 02-oop-concepts.md — OOP Concepts (classes, inheritance, polymorphism, encapsulation, abstraction)

   • Cover: virtual functions, vtable/vptr mechanism, pure virtual functions, abstract classes, multiple inheritance, diamond problem, virtual inheritance, access specifiers, friend functions/classes, operator overloading, copy constructor vs assignment operator, Rule of Three/Five/Zero, object slicing, RTTI, dynamic dispatch.

3. 03-stl.md — STL (vectors, maps, sets, iterators, algorithms)

   • Cover: vector internals (capacity vs size, reallocation), iterator invalidation, map vs unordered_map (red-black tree vs hash table), set vs multiset, std::sort vs std::stable_sort, custom comparators, std::priority_queue, std::deque internals, emplace_back vs push_back, std::move with containers, std::algorithm usage (transform, accumulate, partition, etc.), iterator categories, allocators.

4. 04-templates-and-generics.md — Templates & Generic Programming

   • Cover: function templates, class templates, template specialization (full and partial), SFINAE, std::enable_if, variadic templates, template metaprogramming, constexpr, CRTP (Curiously Recurring Template Pattern), type traits, decltype, auto type deduction, fold expressions, concepts (C++20).

5. 05-smart-pointers-and-modern-cpp.md — Smart Pointers & Modern C++ (C++11/14/17/20)

   • Cover: unique_ptr, shared_ptr, weak_ptr, custom deleters, make_unique/make_shared, circular reference problem, move semantics, perfect forwarding, std::forward, rvalue references, lambda expressions (capture modes), std::optional, std::variant, std::any, structured bindings, if constexpr, std::string_view, noexcept, constexpr functions, ranges (C++20), coroutines overview.

6. 06-concurrency-and-multithreading.md — Concurrency & Multithreading

   • Cover: std::thread, std::mutex, std::lock_guard, std::unique_lock, std::condition_variable, std::atomic, std::async/std::future/std::promise, deadlock prevention, race conditions, producer-consumer problem, reader-writer problem, thread pool design, std::shared_mutex, memory ordering (memory_order_relaxed, memory_order_acquire, memory_order_release, memory_order_seq_cst), std::call_once, thread-safe singleton.

7. 07-data-structures-and-algorithms.md — Data Structures & Algorithms

   • Cover: time/space complexity analysis, hash table collision resolution, balanced BST (AVL, Red-Black), graph algorithms (BFS, DFS, Dijkstra, topological sort), dynamic programming problems, divide and conquer, trie implementation, segment tree, LRU cache implementation, heap operations, quick sort partitioning schemes, merge sort optimization, disjoint set union (Union-Find), sliding window technique, two pointer technique — all with C++ implementations.

8. 08-design-patterns.md — Design Patterns

   • Cover: Singleton (thread-safe), Factory Method, Abstract Factory, Builder, Observer, Strategy, Decorator, Adapter, Command, State, Template Method, Composite, Iterator — all with C++ implementations and real-world use cases, SOLID principles with C++ examples.

9. 09-common-coding-problems.md — Common Coding Problems

   • Cover: 15-20 frequently asked medium-hard coding problems in C++ interviews such as: LRU Cache, implement smart pointer, string manipulation problems, linked list cycle detection, binary tree problems, matrix problems, stack/queue based problems, backtracking problems — each with complete C++ solution, explanation, and time/space complexity.

10. README.md — Update the existing README.md to serve as a table of contents linking to all the above files.

Format for each question file:

# Topic Name — C++ Interview Questions (Medium to Hard)

## Table of Contents
1. [Question 1 title](#q1)
2. [Question 2 title](#q2)
...

---

### Q1: Question text here? <a name="q1"></a>
**Difficulty:** Medium / Hard

**Answer:**
Detailed explanation here...

```cpp
// Code example

Key Takeaways:

• Point 1
• Point 2

---

## Important Not...

</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

*This pull request was created from Copilot chat.*
>