C++ Interview Questions and Answers

First Interview

1. Self-Introduction

Sample Answer

Briefly introduce your personal background, technology stack, and project experience, highlighting the parts relevant to the position. For example: “I mainly use XXXXXX to develop XXXXX, familiar with XXXX, and have worked on XX projects, focusing on solving XXXXX problems.”

Analysis

• Keep it around 1 minute.

• Emphasize skills that match the position.

• Lead into subsequent project challenges that can be elaborated on.

2. Explain OOP

Sample Answer OOP (Object-Oriented Programming) is a programming paradigm centered around objects, with core features including encapsulation, inheritance, and polymorphism.

Analysis

• Encapsulation: Binding data and methods, hiding internal implementation.

• Inheritance: Code reuse, establishing a hierarchy.

• Polymorphism: Same interface, different implementations, enhancing extensibility.

3. Characteristics of Polymorphism

Sample Answer Polymorphism can be divided into compile-time polymorphism (function overloading, templates) and runtime polymorphism (virtual functions).

Analysis

• Compile-time polymorphism: Static binding, determined at compile time.

• Runtime polymorphism: Dynamic binding, implemented through virtual tables, determined at runtime.

4. Virtual Functions vs Pure Virtual Functions

Sample Answer

• Virtual Function: Defined in the base class, can be overridden in derived classes, base class can have an implementation.

• Pure Virtual Function: Declared but not implemented in the base class, defined using <span>=0</span>, requires derived classes to implement, making the base class an abstract class.

Analysis

• Virtual Function: Provides a default implementation that can be overridden.

• Pure Virtual Function: Forces subclasses to implement, commonly used in interface design.

5. Explain STL

Sample Answer STL (Standard Template Library) is a generic library provided by C++, which includes containers, algorithms, iterators, function objects, and adapters.

Analysis

• Containers: vector, map, set, etc.

• Algorithms: sort, find, accumulate, etc.

• Iterators: A unified way to access containers.

6. Iterators vs Pointers

Sample Answer Iterators are generic pointers that can access container elements; pointers are memory addresses.

Analysis

• Iterators: Safer, support various containers, higher abstraction level.

• Pointers: Can only operate on memory addresses, lack container abstraction capability.

7. HTTP vs HTTPS

Sample Answer HTTP transmits in plaintext; HTTPS adds TLS/SSL encryption on top of HTTP to ensure security.

Analysis

• HTTP: Fast but insecure.

• HTTPS: Establishes an encrypted channel through a handshake, preventing eavesdropping and tampering.

8. Symmetric vs Asymmetric Encryption in HTTPS

Sample Answer

• Asymmetric encryption: Used during the handshake phase to exchange symmetric keys using public/private keys.

• Symmetric encryption: Used during data transmission to encrypt and decrypt using the same key, which is faster.

Analysis

• Asymmetric encryption is secure but slow.

• Symmetric encryption is fast but requires secure key transmission.

• Combining both advantages: first asymmetric, then symmetric.

9. TCP Three-Way Handshake and Four-Way Teardown

Sample Answer

• Three-way handshake: Establishes a connection, confirming both parties’ ability to send and receive.

• Four-way teardown: Disconnects the connection, with both parties closing their send and receive channels separately.

Analysis

• Three-way handshake: SYN, SYN+ACK, ACK.

• Four-way teardown: FIN, ACK, FIN, ACK.

10. Why Can’t There Be a Two-Way Handshake

Sample Answer A two-way handshake cannot avoid erroneous connections caused by “stale connection request packets.” The three-way handshake confirms both parties’ ability to send and receive, eliminating the impact of historical packets.

Analysis

• A two-way handshake may cause the server to mistakenly establish a “zombie connection.”

• The three-way handshake confirms with ACK, ensuring connection reliability.

11. Threads vs Processes

Sample Answer A process is the basic unit of resource allocation, while a thread is the basic unit of scheduling.

Analysis

• Process: Independent address space, good isolation, but high switching overhead.

• Thread: Shared address space, low switching overhead, efficient communication.

12. Thread States, Thread Locks, Deadlocks

Sample Answer

• Thread states: New, Ready, Running, Blocked, Terminated.

• Thread locks: Mutex locks, read-write locks.

• Deadlock conditions: Mutual exclusion, non-preemption, hold and wait, circular wait.

• Breaking methods: Destroying the above conditions, such as ordered resource allocation, timeout detection, using CAS.

13. Quick Sort

Sample Answer Quick sort has an average time complexity of O(n log n), worst-case O(n²), space complexity O(log n), and is unstable.

Analysis

• Principle: Choose a pivot, partition and swap, elements less than the pivot go to the left, greater go to the right, and recursively process.

• Optimization: Randomly select pivot, use median of three, use insertion sort for small arrays.

14. Detecting Cycles in a Singly Linked List and Counting Nodes in the Cycle

Sample Answer Use the fast and slow pointer method (Floyd’s cycle-finding algorithm), and after meeting, traverse one more round to count the cycle length.

Analysis

• Detecting cycle: Fast pointer moves two steps, slow pointer moves one step; if they meet, there is a cycle.

• Counting cycle length: Fix one pointer and count while going around.

15. Design Pattern: Singleton Pattern (Thread-Safe)

Sample Answer Commonly used lazy initialization + double-checked locking (DCLP) to implement a thread-safe singleton.

Analysis

class Singleton {public:    static Singleton* getInstance() {        if (!instance) {            std::lock_guard<std::mutex> lock(mtx);            if (!instance) instance = new Singleton();        }        return instance;    }private:    Singleton() {}    static Singleton* instance;    static std::mutex mtx;};

After C++11, static local variables can be used, which are thread-safe and more concise.

16. Two-Way Merge

Sample Answer Merge two sorted arrays using two pointers, taking the smaller element into the result array sequentially.

Analysis

• Time complexity O(m+n).

• Commonly used in merge sort.

Second Interview

1. Self-Introduction

Refer to the first interview answer.

2. Explain the Project (Extend Technical Points from the Project)

Sample Answer Focus on: project background, responsibilities, challenges, solutions. For example, “I was responsible for XXXX, encountered XXXXX issues, and successfully solved them using XXXX, achieving what XXXXX.”

Analysis

• When discussing projects, always link to “technical points” to facilitate extending into topics like language, networking, memory, concurrency, etc.

3. Dynamic Linking vs Static Linking

Sample Answer

• Static linking: Packages libraries into the executable file at compile time, fast startup, simple deployment, but larger file size.

• Dynamic linking: Loads shared libraries at runtime, saving memory, easy to upgrade, but dependent on library environment.

Analysis

• Static linking scenarios: Embedded systems, high performance requirements, stable dependencies.

• Dynamic linking scenarios: Operating system libraries, components that require frequent upgrades.

4. Rust vs C++

Sample Answer

• C++: Extreme performance, mature ecosystem, but memory safety requires manual management.

• Rust: Guarantees memory safety through ownership and borrow checking, avoiding dangling pointers and null references.

Analysis

• Rust advantages: Memory safety, concurrency safety.

• C++ advantages: Extreme performance, comprehensive ecosystem, mature toolchain.

• During interviews, it is recommended to relate to your own projects: for example, using Rust for writing secure modules and C++ for performance-critical parts.

5. Threads vs Processes

Sample Answer A process is the basic unit of resource allocation, while a thread is the basic unit of scheduling.

Analysis

• Process: Independent address space, high switching overhead, strong isolation.

• Thread: Shared address space, low switching overhead, efficient communication, but requires synchronization mechanisms.

6. Process Switching Process

Sample Answer Includes: saving the current process context → updating PCB → switching page tables → loading the next process context.

Analysis

• Save registers, program counter.

• Switch kernel stack, virtual memory mapping.

• Update CPU registers, restore the next process state.

7. How to Measure the Cost of Process Switching

Sample Answer Mainly measure context switch frequency, time, and the impact on CPU cache/TLB.

Analysis

• Cost metrics: Switching delay (microsecond level), CPU utilization drop.

• Tools: Linux <span>perf</span>, <span>vmstat</span>, <span>pidstat</span> can measure context switch frequency.

8. Methods to Debug Concurrent Programs

Sample Answer

• Log printing (with timestamps, thread IDs).

• Use GDB for thread debugging.

• Tools: Valgrind/Helgrind, ThreadSanitizer to check for deadlocks and data races.

Analysis Focus: Use tools to locate race conditions, avoiding reliance solely on printf debugging.

9. Explain Read-Write Locks

Sample Answer Read-write locks allow multiple threads to read simultaneously, but write operations must be exclusive.

Analysis

• When reads are more frequent than writes, performance is better than mutex locks.

• C++ provides <span>std::shared_mutex</span> and <span>std::shared_lock</span>.

10. Heap Memory vs Stack Memory

Sample Answer

• Stack: Automatically managed by the compiler, stores local variables and function call information.

• Heap: Manually allocated by the programmer (new/malloc), must be manually released.

Analysis

• Stack memory is limited, allocation and deallocation are fast.

• Heap memory is larger and flexible, but requires management, prone to leaks and fragmentation.

11. Explain Memory Leaks

Sample Answer Memory leaks occur when memory is allocated but not released, leading to resource exhaustion.

Analysis

• Common causes: Forgetting to delete/free, circular references.

• Tools: Valgrind, ASan to check for leaks.

12. TCP Three-Way Handshake, Why Not Two, Can There Be Four

Sample Answer

• Cannot have two: Two cannot avoid erroneous connections caused by historical packets.

• Four: Theoretically feasible, but three is sufficient to confirm both parties’ sending and receiving capabilities.

Analysis The purpose of the three-way handshake: to confirm both parties’ sending and receiving capabilities, while eliminating the impact of historical packets.

13. map vs unordered_map

Sample Answer

• map: Based on red-black trees, ordered, O(log n) query.

• unordered_map: Based on hash tables, unordered, average O(1) query.

Analysis

• map is suitable for scenarios requiring ordered traversal.

• unordered_map is suitable for fast lookups.

14. How Hash Tables Mitigate Collision Performance Degradation

Sample Answer

• Open addressing: Linear probing, quadratic probing, double hashing.

• Chaining: Array + linked list/red-black tree to store conflicting elements.

Analysis Modern implementations (like C++ unordered_map) commonly use chaining, and when the linked list becomes too long, it converts to a red-black tree to ensure worst-case O(log n).

15. Determine if a String Can Be a Palindrome by Removing at Most One Character

Sample Answer Use two pointers to compare from both ends towards the center; if unequal, try skipping one side to continue checking.

Analysis

• Time complexity O(n), space complexity O(1).

Example code:

bool validPalindrome(string s) {    int l = 0, r = s.size() - 1;    while (l < r) {        if (s[l] != s[r]) {            return isPalindrome(s, l+1, r) || isPalindrome(s, l, r-1);        }        l++; r--;    }    return true;}bool isPalindrome(const string&amp; s, int l, int r) {    while (l < r) if (s[l++] != s[r--]) return false;    return true;}

Third Interview

1. Discuss the Project (Extend Technical Questions)

Sample Answer Focus on: project background, responsibilities, challenges, solutions. For example, “I was responsible for XXXX, encountered XXXXX issues, and successfully solved them using XXXX, achieving what XXXXX.”

Analysis

• When discussing projects, always link to “technical points” to facilitate extending into topics like language, networking, memory, concurrency, etc.

2. Compare C++ and Python, Why is Python Slower than Other Scripting Languages

Sample Answer Python’s execution speed is slower mainly because it is an interpreted dynamic language, requiring type checks, memory management, and other operations at runtime.

Analysis

• C++: A compiled language, code is compiled into machine instructions, resulting in high execution efficiency.

• Python: An interpreted language, executed line by line; uses a Global Interpreter Lock (GIL), limiting concurrency.

• Compared to other scripting languages, Python emphasizes readability and has a rich standard library, but its performance is not as good as C/C++.

3. C++ Compilation Process and Optimization

Sample Answer The compilation process includes: preprocessing → compiling → assembling → linking.

Analysis

• Preprocessing: Handles macros, header files.

• Compiling: Converts source code to assembly, generating IR (Intermediate Representation) in the process.

• Assembling: Generates target machine instructions.

• Linking: Merges object files and libraries to generate an executable file.

• Optimization: The compiler can perform constant folding, loop unrolling, inlining, dead code elimination; more advanced optimizations like LTO (Link Time Optimization).

4. RISC vs CISC

Sample Answer

• RISC (Reduced Instruction Set Computer): Simple instructions, fast execution, relies on compiler optimization.

• CISC (Complex Instruction Set Computer): Complex instructions, can perform more functions, but lower execution efficiency.

Analysis

• RISC: ARM, RISC-V, suitable for embedded and mobile devices.

• CISC: x86, complex instructions but strong compatibility.

• Trend: Modern processors combine the advantages of both (e.g., x86 also translates complex instructions into micro-operations internally).

5. OS Related Open-Ended Question: Implementing Copy and Paste

Sample Answer Data exchange between different applications can be achieved through a clipboard (shared memory/IPC).

Analysis

• Implementation Idea:

• Applications write data to the clipboard (shared memory/system buffer).

• Another application reads the data.

• Shared Memory Risks: Concurrent access can lead to data races.

• Solutions: Use locks, semaphores/mutexes, versioning mechanisms.

• File Copy Strategy:

• Direct copy: Consumes disk space.

• Copy-on-Write: Initially only copies references, actual data is copied only when modified, reducing unnecessary copies.

6. Common Mobile App (Bilibili) Video Stuttering Causes

Sample Answer Video stuttering may be caused by network, decoding, system scheduling, and other issues.

Analysis

• Network level: Insufficient bandwidth, high latency, packet loss.

• Buffer level: Player buffer running out (Buffer underrun).

• Decoding level: Insufficient CPU/GPU performance, slow decoding speed.

• System level: I/O scheduling, insufficient thread priority, leading to decoding or rendering delays.

• Solutions: Adaptive bitrate (ABR), preloading, hardware decoding optimization.