在C++中是否应优先使用qsort而非sort？存在qsort更适用的场景吗？

Great question! In most modern C++ codebases, std::sort is the clear go-to—it’s type-safe, generally faster (thanks to template inlining and compile-time optimizations), and plays seamlessly with STL containers. But there are a few niche scenarios where reaching for the C-style qsort might make more practical sense:

• Working with legacy C codebases
  If you’re integrating or maintaining old C code that already defines comparison functions for qsort, sticking with qsort saves you from rewriting those functions into C++-friendly lambdas or functors. For example, if you have an existing int compare_custom_structs(const void* a, const void* b) that handles complex sorting logic for a C struct, using qsort avoids the overhead of wrapping or refactoring that code just to use std::sort.

• Dynamic runtime comparison rules
  Since qsort uses a function pointer for comparisons, you can swap out sorting logic at runtime without recompiling template instances. Suppose your app lets users choose between sorting a dataset by name, ID, or timestamp—with qsort, you can just pass a different function pointer based on user input. With std::sort, you’d either need multiple template instantiations or a stateful comparator, which can add complexity or minor performance overhead.

• Sorting untyped byte buffers
  When dealing with raw, untyped byte data (like a buffer of unknown structs or serialized records), qsort’s void* interface is more flexible. For example, if you need to sort a unsigned char array where each element is a fixed-size byte blob representing a custom record, qsort’s comparison function can directly inspect those bytes. std::sort requires a concrete type, forcing you to cast the buffer first, which adds extra code and potential safety risks if done incorrectly.

• Extremely memory-constrained environments
  In tiny embedded systems or environments where ROM space is at a premium, qsort has a smaller code footprint. std::sort is a template function, so each unique combination of type and comparator generates a new instance of the function, which can bloat the binary. qsort is a single, non-templated function, making it more efficient in terms of code size when every byte counts.

It’s worth emphasizing that these cases are rare—for almost all standard C++ use cases, std::sort is the better choice due to its type safety, better performance, and integration with modern C++ features.

内容的提问来源于stack exchange，提问作者Vedant Dixit