Interview Experience for C++ Development at Insta360

First Interview

1. Interviewer Self-Introduction

2. Self-Introduction

Reference Answer 30–60 seconds “four-part format”: Background → Tech Stack → Representative Projects → Quantified Results;

3. Memory Layout of Classes

Reference Answer

No virtual functions: Object = Order of data members + Alignment padding; when containing a base class, the “base class sub-object” is at the front.
With virtual functions: The object header (usually) contains a vptr pointing to the vtable; multiple vptrs and this adjustments may occur with multiple/virtual inheritance.
Empty Base Optimization (EBO): An empty base class does not occupy additional space through inheritance.

Analysis

sizeof is affected by alignment and padding;[[no_unique_address]] (C++20) further compresses layout; accessing reused storage requires caution with std::launder.

4. When will an object have multiple virtual table pointers?

Reference Answer

Multiple Inheritance: Each base class sub-object containing virtual functions usually has its own vptr.
Virtual Inheritance: To locate shared virtual base classes, offset tables/secondary tables are introduced, and the actual object may have multiple vptrs/offset slots.

Analysis This explains why dynamic_cast and conversions from base to derived require this adjustments.

5. Where is the virtual table generally stored?

Reference Answer The vtable is stored in the read-only data segment (e.g., .rodata), which is a static table generated at compile time;vptr is within the object.

Analysis Different compilation units may generate their own vtable; when crossing so, attention must be paid to ODR and RTTI consistency (ABI compatibility).

6. Lvalues and Rvalues

Reference Answer

Lvalue: Has persistent storage, can take address (named objects, dereferencing).
Pure Rvalue (prvalue): Temporary, literal; xvalue (expiring value): Rvalue that can be “moved” (e.g., std::move(x)).

Analysis Overload matching priority:T& accepts lvalues, T&& accepts rvalues; Universal references (template T&&) + deduction will “reference fold” (lvalue folds into T&).

7. Move Semantics

Reference Answer Replace expensive “copying content” with “transferring ownership” (pointer/handle migration), achieving O(1) level “transportation”.

Key: Custom move constructor/move assignment, and try to noexcept (affects container expansion strategy).
std::move merely converts the expression to xvalue; whether it actually “moves” depends on the type implementation.

Analysis Exception safety: Strong guarantee/basic guarantee choices; after moving, the source object is in a destructible but unspecified state, and can only be assigned new values or destroyed.

8. RAII

Reference Answer Bind the resource lifecycle to the object: Acquire on construction, release on destruction. Typical:unique_ptr (memory), lock_guard (lock), fstream (file), shared_ptr (shared).

Analysis RAII + scope exit (including exceptions) = automatic cleanup; any C interface that requires “must be called in pairs” can be wrapped in RAII.

9. What happens if a constructor or destructor throws an exception?

Reference Answer

Constructor can throw; once thrown:

Members and base class sub-objects that have been constructed will automatically destruct (in reverse order);
The current object itself is not fully constructed, and its destructor will not be called;
Therefore, there is no need to force catch in the constructor, as long as each resource is encapsulated as an RAII member to avoid leaks.

Destructor should not throw exceptions; if it throws during stack unwinding, the program will std::terminate(). It should swallow/record exceptions in the destructor.

Analysis Key point: Exception propagation is fine, provided that resources are released in the destructors of “constructed members”; destructors must not leak exceptions.

10. What is the purpose of `dynamic_cast`?

Reference Answer Perform runtime safe casting within a polymorphic hierarchy (requires RTTI and virtual tables):

Base → Derived: Failure returns nullptr/throws bad_cast;
In multiple/virtual inheritance, it will perform the correct this adjustments.

Analysis Avoid hot paths; if statically determinable, use static_cast; the base class must contain virtual functions to have RTTI.

11. How to make an object only allocatable on the stack?

Reference Answer Delete operator new/new[]:

struct StackOnly {  StackOnly()=default; ~StackOnly()=default;  void* operator new(std::size_t) = delete;  void* operator new[](std::size_t) = delete;};

Analysis Conversely, to allow only heap allocation: set the destructor to private/protected, create through make_unique/factory, prohibiting automatic destruction on the stack.

12. Function Calling Conventions

Reference Answer Specify parameter passing/return value/stack balance methods:

x86:__cdecl (caller cleans stack), __stdcall (callee cleans stack), __thiscall (member function), __fastcall (register parameter passing).
x64: System V (Linux/Unix) and Win64 each have fixed register passing rules and stack shadow areas.
ARM: AAPCS; also vectorcall etc.

Analysis Cross-language/plugin/dynamic loading must match conventions; mismatches lead to crashes.

13. SOLID Principles

Reference Answer S Single Responsibility, O Open/Closed, L Liskov Substitution, I Interface Segregation, D Dependency Inversion.

Analysis C++ practice: Interface Segregation → fine-grained pure virtual interfaces or concepts (C++20); Dependency Inversion → depend on abstractions or template parameters; Open/Closed → use composition/strategy/CRTP instead of inheritance branches.

14. Which STL containers have you used?

Reference Answer

Sequence:vector (contiguous memory, cache-friendly), deque (efficient at both ends), list/forward_list (stable iterators), array, string.
Associative:map/set (red-black tree, logN), unordered_map/set (hash, expected O(1)).
Adapters:queue/stack/priority_queue.

Analysis Emphasize “iterator stability”, “memory layout”, and “complexity with typical scenarios”.

15. What is the role of STL allocators?

Reference Answer Containers request/release element storage from allocators (allocate/deallocate), hiding strategies for alignment, pooling, NUMA affinity, huge pages, shared memory, etc.

Analysis In engineering, custom allocators can be defined: pooling small objects, binding NUMA, aligning to cache lines, reducing fragmentation and false sharing.

16. What happens during vector expansion?

Reference Answersize==capacity triggers: Calculate new capacity (implementation-dependent, often 1.5–2 times) → Allocate new memory → move construction (if not noexcept may revert to “copy construction”) to migrate elements → Destruct old elements → Release old memory → Update pointers.

Analysisnoexcept(move) will prioritize moving, significantly affecting expansion costsreserve(n) can reduce multiple expansions.

17. Iterator invalidation

Reference Answer

vector/string: Expansion or insertion may invalidate all iterators; deletion invalidates those after the deleted position.
deque: Insertion at both ends often invalidates;
list/forward_list: Insertion/deletion does not affect other iterators (except the deleted element);
map/set: Insertion/deletion does not affect other iterators (except the deleted);
unordered_*: rehash invalidates all.

Analysis For stable iterators, choose list/map; for high-frequency traversal + random access, choose vector and avoid mid-expansion.

18. The process from source file to executable file

Reference Answer Preprocessing (macro/include expansion) → Compilation (semantic analysis, IR, optimization, assembly generation) → Assembly (object file .o) → Linking (static/dynamic, generating ELF/PE).

19. The linking process

Reference Answer

Symbol Resolution: Match undefined references with definitions, handling strong/weak symbols and duplicate definitions;
Relocation: Fix addresses (relocation table), merge segments and allocate final addresses;
Static linking copies library members in; dynamic linking defers resolution to runtime.

Analysis Violating ODR (One Definition Rule) leads to hard-to-locate UB; when crossing so, pay attention to ODR of inline/template instances.

20. Dynamic linking, GOT, PLT

Reference Answer

At runtime, ld.so loads .so, resolving dynamic segments (DT_NEEDED) and dependencies.
PLT: Procedure Linkage Table; the first call jumps to the resolver, which writes to GOT after resolution.
GOT: Global Offset Table; stores actual addresses of functions/data, called via indirect jumps thereafter.

Analysis

Lazy binding vs immediate binding; lookup paths are affected by RUNPATH/RPATH/LD_LIBRARY_PATH.

21. Program startup from the OS perspective

Reference Answer execve: Kernel reads ELF → Establishes virtual memory mapping (.text/.data/.bss/heap/stack/TLS/shared libraries) → Transfers control to dynamic loader → Resolves and maps dependencies → Runs .init_array (constructors) → Jumps to main.

Analysis The initial user stack contains argv/envp/auxv; ASLR randomizes the base addresses of each segment.

22. Process address space

Reference Answer Typical: Code segment, read-only data, writable data, heap (grows upward), mapping area (mmap), thread stack (grows downward), TLS, kernel mapping.

Analysis Each thread has an independent stack and TLS; the 64-bit address space is vast but may not be fully usable due to kernel/ASLR limitations.

23. How does the OS manage the heap?

Reference Answer User-level malloc/new is implemented by allocators (ptmalloc/jemalloc/tcmalloc):

Small blocks: arena/tcache splitting;
Large blocks: directly mmap;
Backends request memory from the kernel via brk/sbrk or mmap;
Reclamation: Merge adjacent free blocks, return dirty pages to the system, background thread cleanup.

Analysis Tuning: mallopt/mallctl parameters, NUMA affinity, HugePage, fragmentation management, and cross-thread release backflow.

24. The process of a system call

Reference Answer User mode encapsulates the system call number + parameters into registers → Triggers syscall/sysenter → CPU switches to kernel mode/kernel stack → Executes kernel service → sysret returns; error codes are placed in -errno, converted to errno by the C library.

Analysis The cost is not low: use batching/asynchronous (io_uring), mmap/ioctl, etc., to reduce the number of syscalls.

25. What types of locks are there?

Reference Answer

Mutex:mutex, recursive_mutex;
Spinlock:spinlock (short critical section, cannot sleep);
Read-Write:shared_mutex;
Condition:condition_variable;
Counting:semaphore (C++20)/POSIX;
Barrier:barrier/latch (C++20);
Others: One-time initialization call_once, RCU, seqlock (read lock-free/write with versioning)

Analysis Choose: Read-heavy write-light prefer read-write locks/RCU; avoid blocking I/O within locks; use heavy locks cautiously across cores.

26. When does a deadlock occur?

Reference Answer The four conditions of Coffman must be met: Mutual exclusion, Hold and wait, No preemption, Circular wait. Typical: Inconsistent lock order, reverse locking in callbacks, holding locks while doing I/O/waiting for conditions.

Analysis Global lock order/hierarchy, try-lock with timeout, refine lock granularity, avoid blocking I/O within locks, design to avoid circular dependencies.

27. How to locate a deadlock?

Reference Answer

On-site:gdb/pstack exports all thread stacks; see who holds what locks and is stuck on which futex;
Tools:perf lock, eBPF observe futex/sched;
Engineering: Record owner/position for critical locks, establish lock order checks; timeout automatically dumps thread and resource graphs.

Analysis Online, there should be timeout and automatic sampling, rather than relying on manual SSH checks.

28. How to write Makefile/CMakeLists

Reference Answer

Makefile: Target-oriented organization;$@/$</$^; -MMD -MP generates header dependencies; distinguish Debug/Release; .PHONY; split common rules and modules.
CMake: Target-oriented:add_library/add_executable, target_link_libraries, target_include_directories, target_compile_options, target_compile_features(C++17/20); enable POSITION_INDEPENDENT_CODE, INTERFACE library export compile options.

Analysis Avoid global variable pollution, use “target-private/interface” properties as much as possible; do multiple configurations and multi-platform matrices in CI.

29. How to debug memory leaks or crashes

Reference Answer

Leaks: ASan/LSan, Valgrind/heaptrack, statistical interfaces (mallinfo/jemalloc mallctl);
Crashes: core dump + gdb bt/full, addr2line, ASan/UBSan;
Online: Enable core (/proc/sys/kernel/core_pattern), retain symbol files, crash reporting and version fingerprinting.

Analysis First, reproduce minimally, then replay requests or construct the same lifecycle; prioritize opening ASan/UBSan for UAF/out-of-bounds detection.

30. How to analyze online issues

Reference Answer Monitoring alarms → Hemostasis → Layered positioning → Rollback/Fix → Review:

Metrics: Percentile latency, QPS, error codes, resources (CPU/memory/IO/network), queues, and packet loss.
Tools:perf/eBPF/flame graph, ss/tcpdump, iostat/sar, application logs/Trace.
Hemostasis: Rate limiting/circuit breaking/isolate hotspots, scaling down/up, rollback.

Analysis Review must be actionable: root cause, monitoring gaps, automated regression test cases, change strategies (canary/slow start).

31. Counter-questions

Reference Answer

What performance/stability pain points does the team currently hope the new colleague will solve? What are the milestones and evaluation metrics for the first three months?
What is the division of labor and collaboration boundaries between C++/Go/Python in the link? How are the release/rollback, observability, and pressure testing systems structured?
Which modules do newcomers usually start with? What is the rhythm of the mentoring system and code review?

Analysis Counter-questions that are “actionable + executable” reflect your goal orientation and help you assess fit.

Second Interview

1. Self-Introduction

Refer to the first interview.

2. Introduction to commonly used STL containers

Reference Answer

Sequence:vector (contiguous memory, random access O(1)), deque (segmented blocks, efficient at both ends), list/forward_list (stable iterators, insertion/deletion O(1)), array (fixed length), string.
Associative (ordered):map/set (red-black tree, logN; stable iterators).
Associative (unordered):unordered_map/set (hash, expected O(1); rehash invalidates iterators).
Adapters:queue/stack/priority_queue.

Analysis When answering about containers, it is best to include complexity + iterator stability + typical scenarios.

3. Differences between vector and deque

Reference Answer

Memory:vector is contiguous, deque is segmented (map + blocks).
Operations:vector is fast for tail insertion, slow for head insertion; deque is fast for both head and tail insertion.
Iterator invalidation:vector expansion almost invalidates all; deque insertion/deletion may invalidate iterators, but references/pointers are generally more stable.
Random access: Both have O(1), vector is more cache-friendly.

Analysis When stable head operations and large queues are needed, use deque; when compactness/extreme traversal performance is needed, use vector.

4. Differences between map and unordered_map

Reference Answer

Underlying:map is a red-black tree (ordered), unordered_map is a hash table (unordered).
Complexity: logN vs expected O(1).
Iterator stability:map insertion/deletion does not affect other iterators (except the deleted), unordered_map rehash invalidates all.
Scenarios: Use map for range/ordered traversal/lower bound search; use unordered_map for many equal value lookups.

Analysisunordered_map performance is affected by load factor/hash/equivalence relation; custom keys require providing hash and ==.

5. Why not use AVL trees for map?

Reference Answer AVL trees are more “strictly balanced”, slightly better for lookups, but insertions/deletions require more rotations, leading to higher maintenance costs; red-black trees are more balanced in terms of insert/delete/search performance and implementation complexity, and iterator stability is easier to guarantee.

Analysis The standard library emphasizes overall constants/traversal locality/implementation complexity, making red-black trees a pragmatic choice.

6. What common locks are there?

Reference Answer Mutex (mutex/recursive_mutex), spinlocks, read-write locks (shared_mutex), condition variables, semaphores (C++20 counting_semaphore), one-time initialization (call_once), barriers/latches (C++20 barrier/latch).

Analysis Short critical sections and cannot sleep → spinlocks; read-heavy write-light → read-write locks/RCU; need to wait for conditions → condition variables.

7. Are you familiar with lock-free programming?

Reference Answer Based on atomic operations (CAS, FAA) to build concurrent structures, such as lock-free queues/stacks, circular buffers; advantages include avoiding blocking and reducing scheduling overhead; challenges include ABA, memory reclamation (Hazard Pointers/epoch/RCU), and memory ordering.

Analysis C++ atomic memory order:seq_cst (strongest), acq_rel, acquire/release, relaxed; defaults downgrade from strong to weak as needed, with accompanying annotations.

8. Causes of deadlock

Reference Answer The four conditions of Coffman: Mutual exclusion, Hold and wait, No preemption, Circular wait.

Analysis Common: Inconsistent lock order, blocking I/O while holding locks, reverse locking in callbacks, interleaving locks with condition variables/external resources.

9. How to troubleshoot deadlocks?

Reference Answer

On-site:gdb/pstack dumps all thread stacks; locate threads blocked on futex/pthread_mutex_lock.
Tools:perf lock, eBPF trace futex/sched; print lock owner and position.
Engineering: Establish global lock order, add owner/timeout for critical locks, automatically collect thread stacks and resource graphs on timeout.

Analysis There should be an “automated evidence chain” online, avoiding reliance on manual SSH.

10. Discuss the static keyword

Reference Answer

C:Internal linkage (file scope static), static storage duration (function-local static persists).
C++: Class-level static members (shared, not tied to objects); function/variable internal linkage same as C.

Analysisstatic can refer to both linkage attributes and storage duration; class-level static member functions have no implicit this.

11. Initialization timing of static global variables and static local variables

Reference Answer

Static global/namespaced static: Before program startup (static initialization/dynamic initialization, order across translation units is uncertain).
Function-local static:Initialized on first call (guaranteed thread-safe since C++11), reused thereafter.

Analysis For cross-unit dependencies, use “construction order safety” schemes: function-local statics or “lazy singleton”.

12. Why are templates generally written in header files?

Reference Answer Templates need to be visible at the point of instantiation to avoid linker errors; placing them in header files allows the compiler to generate specific instances when used.

Analysis Explicit instantiation can be used with extern template class Foo<int>; + .cpp definitions to reduce compile time and duplicate code.

13. What is virtual memory?

Reference Answer Provides each process with an independent virtual address space; maps virtual pages to physical pages/files/swap space via page tables, providing isolation, on-demand allocation, memory mapping, etc.

Analysis Costs: Page table usage, TLB misses, page fault overhead; benefits: security and flexibility.

14. Common page replacement algorithms

Reference Answer FIFO, LRU, Clock (second chance), LRU approximation (activity bits), LFU; Linux’s active/inactive lists, reverse mapping, and hot/cold reclamation approach LRU-approx.

Analysis Pure LRU has high maintenance costs; practical implementations often use approximation algorithms to balance accuracy and overhead.

15. Processes, threads, coroutines

Reference Answer

Process: Resource/isolation unit, independent virtual address space.
Thread: Scheduling unit, shared address space.
Coroutine:User-mode scheduled lightweight tasks, switching without kernel traps; when encountering blocking I/O, must pair with non-blocking + multiplexing.

Analysis Costs: Process switching > thread switching > coroutine switching; coroutines are still limited by single-core execution (see next question).

16. How do coroutines utilize multiple cores?

Reference Answer Use M:N scheduling: Multiple worker threads (M) each run a scheduler, distributing many coroutines (N) across different thread cores; each thread has an event loop (epoll/kqueue) + work-stealing for load balancing.

Analysis Key point: Avoid cross-thread migration that causes cache thrashing; pool CPU tasks and I/O tasks separately.

17. Which coroutine libraries have you used?

Reference Answer Such as libco, libgo, Boost.Context + self-developed scheduling, folly fibers, Qt coroutine (C++20 co_await ecosystem like cppcoro).

Analysis When answering, point out:stack saving/restoration mechanisms, integration with epoll, timers/timeouts, cross-thread scheduling strategies.

18. IO Multiplexing

Reference Answer select/poll (linear scan), epoll (event-driven, ET/LT two modes), kqueue (BSD), IOCP( Windows, completion ports); Linux can also use io_uring for true asynchronous.

Analysis epoll ET requires non-blocking + a read/write loop until EAGAIN; register once, edge-triggered reduces wake-ups.

19. TCP Three-Way Handshake and Four-Way Termination

Reference Answer

Three-way handshake: SYN → SYN|ACK → ACK establishes connection;
Four-way termination: FIN → ACK → FIN → ACK closes.

Analysis The three-way handshake synchronizes the initial sequence numbers and capabilities of both parties, while the four-way termination is due to the half-close of two unidirectional streams terminating separately.

20. Why three-way handshake, can it be two or four times?

Reference Answer Two times is not sufficient: it must allow the initiator to confirm that the other party has received its initial sequence number (self-confirmation), to avoid old SYN causing false connections. Four times is unnecessary: three times already completes bidirectional confirmation and capability negotiation.

Analysis The three-way handshake includes exchange and confirmation of both parties’ ISNs; two handshakes cannot confirm “your ACK is a confirmation of my SYN”.

21. Can three-way termination be done in three steps?

Reference Answer Theoretically, if the passive party combines FIN and ACK (half-close and confirmation sent simultaneously), it appears to be “three times”, but essentially it is still one FIN sent in each direction, just merging the two steps into one packet does not change the semantics.

Analysis Closing is bidirectional termination, requiring at least one FIN to be sent by each party.

22. What is TIME_WAIT?

Reference Answer The active closing party enters TIME_WAIT, maintaining 2MSL to ensure that FIN/ACKs that may be retransmitted by the other party can be correctly received and not confused with subsequent new connections.

Analysis A large number of short connections can accumulate TIME_WAIT; management strategies include connection reuse, expanding port ranges, server SO_REUSEPORT for load balancing, and cautious use of tcp_tw_reuse( (deprecated in new kernels)tw_recycle).

23. Project experience

Reference Answer STAR describes 1–2 closed loops: Problem → Positioning → Changes → Results → Consolidation.

Analysis You can include “rejected solutions + reasons” to reflect trade-offs.

24. Internship experience

Reference Answer Describe according to “Responsibilities – Challenges – Breakthroughs – Review”: the module you were responsible for, the core issues encountered, the tools/methods you used, result data, and the documentation/scaffolding/specifications retained.

Analysis Use real numbers and detailed screenshots (orally) to enhance credibility.

25. How to analyze the overhead of function calls

Reference Answer

Micro: -O2/-O3 whether it can be inlined; whether it crosses dynamic libraries (PLT/GOT indirect jumps); calling conventions and register saving; whether it throws exceptions; whether not noexcept causes containers not to inline/not move.
Metrics: -pg/gprof (old), perf record + report, flame graphs; -fno-omit-frame-pointer keeps stack frames.

Analysis Hot functions: inline + avoid virtual calls + avoid cross-so jumps + noexcept moves, then consider algorithm constants and cache locality.

26. Handwritten: Maximum Subarray Sum

Reference Answer (Kadane, O(n), O(1) space)

int maxSubArray(const vector&lt;int&gt;&amp; a) {    long long best = LLONG_MIN, cur = 0;    for (int x : a) {        cur = max&lt;long long&gt;(x, cur + x); // Optimal ending at current position        best = max(best, cur);    }    return (int)best;}

Can space be optimized?

The above is already O(1) extra space; if the output interval is needed, the start/end indices can be recorded during updates.

Can time be optimized? The theoretical lower bound is Ω(n): each element affects the answer, and it must be seen once. What can be done is parallel divide and conquer (multi-core) to reduce wall time to ~O(n/p + merge constant).

Why can’t it be binary searched?

Binary search requires the answer to be monotonic with respect to some predicate (e.g., “is it feasible” is monotonic with respect to the threshold). The maximum subarray sum does not have such a monotonic decidable predicate: given a threshold T, “is there a subarray sum ≥ T” can be determined linearly, but the feasible set for T is not necessarily monotonic (different array segment combinations lead to non-monotonic boundaries), and binary search still requires O(n) checks each time, leading to an overall O(n log R), worse than O(n).

Analysis A divide-and-conquer method can also be given: maintain a quadruple (total sum, prefix max, suffix max, interval max), merging left and right subproblems, complexity O(n log n), educational significance > practical value.

27. Counter-questions

Reference Answer

What performance/stability pain points does the team currently hope the new colleague will solve? What are the milestones and evaluation metrics for the first three months?
What is the division of labor and collaboration boundaries between C++/Go/Python in the link? How are the release/rollback, observability, and pressure testing systems structured?
Which modules do newcomers usually start with? What is the rhythm of the mentoring system and code review?

Analysis Counter-questions that are “actionable + executable” reflect your goal orientation and help you assess fit.

1. Interviewer Self-Introduction

2. Self-Introduction

3. Memory Layout of Classes

4. When will an object have multiple virtual table pointers?

5. Where is the virtual table generally stored?

6. Lvalues and Rvalues

7. Move Semantics

8. RAII

9. What happens if a constructor or destructor throws an exception?

10. What is the purpose of <span>dynamic_cast</span>?

11. How to make an object only allocatable on the stack?

12. Function Calling Conventions

13. SOLID Principles

14. Which STL containers have you used?

15. What is the role of STL allocators?

16. What happens during vector expansion?

17. Iterator invalidation

18. The process from source file to executable file

19. The linking process

20. Dynamic linking, GOT, PLT

21. Program startup from the OS perspective

22. Process address space

23. How does the OS manage the heap?

24. The process of a system call

25. What types of locks are there?

26. When does a deadlock occur?

27. How to locate a deadlock?

28. How to write Makefile/CMakeLists

29. How to debug memory leaks or crashes

30. How to analyze online issues

31. Counter-questions

1. Self-Introduction

2. Introduction to commonly used STL containers

3. Differences between vector and deque

4. Differences between map and unordered_map

5. Why not use AVL trees for map?

6. What common locks are there?

7. Are you familiar with lock-free programming?

8. Causes of deadlock

9. How to troubleshoot deadlocks?

10. Discuss the static keyword

11. Initialization timing of static global variables and static local variables

12. Why are templates generally written in header files?

13. What is virtual memory?

14. Common page replacement algorithms

15. Processes, threads, coroutines

16. How do coroutines utilize multiple cores?

17. Which coroutine libraries have you used?

18. IO Multiplexing

19. TCP Three-Way Handshake and Four-Way Termination

20. Why three-way handshake, can it be two or four times?

21. Can three-way termination be done in three steps?

22. What is TIME_WAIT?

23. Project experience

24. Internship experience

25. How to analyze the overhead of function calls

26. Handwritten: Maximum Subarray Sum

27. Counter-questions

Related posts

Leave a Comment Cancel reply

10. What is the purpose of `<span>dynamic_cast</span>`?