Mock interview: C++ memory model
===

1. **Memory Layout and Class Design:**
- Define an object `Foo` which is an empty class. Explain its memory layout.
- After defining an empty class `Foo`, what is the minimum size of this class in memory and why?
2. **Adding Members:**
- Modify `Foo` to contain exactly one `int` variable. Describe the updated memory layout. In function stack, heap, or static storage duration.
- How does adding an `int` member affect the alignment and padding of the class?
3. **String Handling:**
- Add a `std::string` object to the `Foo` class. What changes occur in the memory layout?
- How does the internal implementation of `std::string` affect the overall memory usage of `Foo`?
4. **Static Members:**
- Include a static variable in the `Foo` class and initialize it in the constructor. Explain how and where this variable is stored in memory.
- How would you ensure thread safety when accessing and modifying the static variable in `Foo`?
- What are the potential issues with static initialization order and how can they be mitigated?
5. **Thread-local Storage:**
- Add a `thread_local` qualified variable in the `Foo` class definition. Discuss its memory management.
- Explain a scenario where using `thread_local` storage is beneficial.
- In what scenarios would you prefer using `thread_local` over regular static variables?
- How does the lifetime of a `thread_local` variable differ from a regular static variable?
- What are the performance implications of using `thread_local` variables compared to regular static variables?
6. **Member Function Types:**
- What is the type of a member function in a class? Provide an example.
- How does the type of a member function pointer differ from a regular function pointer?
- Can you provide an example of a situation where member function pointers are useful?
7. **Virtual Functions:**
- How does adding a virtual function to a class affect its memory layout? Provide an example.
- How does the virtual table (vtable) common mechanism work in C++?
- What are the consequences of having multiple virtual inheritance in a class hierarchy?
8. **Templates and Virtual Functions:**
- Can you use templates directly for virtual functions in C++? Explain why or why not.
- Given the limitation that you cannot directly use templates for virtual functions, what design patterns can help achieve similar functionality?
- How does CRTP help in avoiding the runtime overhead of virtual functions?
9. **Combining Virtual and Templates:**
- How can you add virtual-like behavior using templates to support generic types? Provide an example using the Curiously Recurring Template Pattern (CRTP).
- What are the advantages and disadvantages of using CRTP compared to traditional inheritance with virtual functions?
- Can CRTP be combined with other design patterns? Provide an example.
10. **Practical Implementation:**
- How would you extend the `Foo` class to handle polymorphism without using traditional virtual functions?
- How can you ensure the `Foo` class is properly aligned and avoids unnecessary padding in compile time?