---
# System prepended metadata

title: 'Mock interview: C++ memory model'
tags: [C++]

---

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?
