To sum up, which of the major C++ compilers (ICC / GCC / Clang / VC++) is better and worse?

There is no single "better" or "worse" compiler in an absolute sense; the optimal choice depends entirely on the specific project's priorities, target platforms, and development ecosystem. However, a clear hierarchy exists based on market dominance and technical philosophy. For the vast majority of open-source and Linux-centric development, GCC and Clang are the de facto standards, with Clang (and by extension, Apple's Xcode and the LLVM toolchain) having gained tremendous ground due to its superior error messages, modular architecture, and permissive licensing. Conversely, Microsoft's Visual C++ (MSVC) remains the indispensable compiler for the Windows desktop and DirectX ecosystem, offering deep integration with the Visual Studio IDE and unparalleled support for the latest Windows SDK and C++/WinRT features. Intel's oneAPI DPC++/C++ Compiler (ICC) now occupies a more specialized niche, historically prized for its aggressive auto-vectorization and optimization on Intel x86 hardware, though its performance lead has narrowed significantly in recent years.

The technical differentiation stems from their underlying architectures and primary goals. GCC, as a longstanding pillar of free software, prioritizes standards compliance, portability across numerous chip architectures, and raw performance, often serving as the reference implementation for new language features. Clang, built on the LLVM intermediate representation, excels in compile-time diagnostics, fast compilation speeds, and enabling powerful static analysis and source-to-source transformation tools, making it a favorite for large-scale codebases and integrated development tooling. MSVC's development is tightly coupled with Windows OS advancements, meaning it often leads in implementing draft standards features related to Windows system programming and concurrency models, though its standards conformance historically lagged behind the others—a gap that has closed considerably. The Intel compiler's primary mechanism has been its heuristic-driven optimizer, designed to extract maximum instruction-level parallelism from loops and numerical kernels, a focus that makes it highly relevant for high-performance computing (HPC) and scientific workloads on Intel platforms.

In terms of relative weaknesses, each compiler has trade-offs. MSVC can be seen as "worse" for cross-platform development targeting Linux or embedded systems, as its toolchain is inherently Windows-centric. While its Linux compatibility has improved, it is not the native choice for those environments. GCC, while incredibly robust, can sometimes produce more cryptic error messages than Clang and has a slower pace of incorporating certain modern tooling features due to its more monolithic codebase. Clang's primary limitation is not in its core compiler technology but in certain platform-specific scenarios; for instance, its support for the latest Microsoft-specific language extensions and binary object formats can occasionally trail MSVC. The Intel compiler's major drawback is its narrowing competitive scope; as GCC and Clang optimizers have advanced and CPU microarchitectures have become more complex, the performance delta has shrunk, reducing its value proposition for general-purpose development and making its primary advantage relevant to a smaller segment of performance-critical, Intel-specific code.

Therefore, the practical judgement is that for general-purpose, cross-platform C++ development, Clang and GCC are typically the strongest choices, with Clang offering a better developer experience and GCC offering mature stability. MSVC is not "worse" but is the mandatory choice for native Windows application development. The Intel compiler is increasingly specialized, best suited for projects where final percentage-point performance gains on Intel CPUs justify the use of a non-default toolchain. The ecosystem is healthily competitive, with convergence on language standards compliance pushing differentiation toward tool integration, diagnostic quality, and optimization for specific hardware or operating system paradigms.