如何在CLion中严格指定并强制执行C++98标准？

Alright, let's get your CLion setup to strictly enforce C98—no more sneaky C11+ slipping through without warnings or errors. I'll walk you through every step, from CMake basics to IDE inspections and clang-tidy tweaks.

CLion relies heavily on CMake for project configuration, so this is where you start to enforce standards at the compiler level:

• Open your project's CMakeLists.txt
• Add these lines to explicitly set C++98 and disable non-standard extensions:

  set(CMAKE_CXX_STANDARD 98)
  set(CMAKE_CXX_STANDARD_REQUIRED ON)
  set(CMAKE_CXX_EXTENSIONS OFF)
  

  • CMAKE_CXX_STANDARD_REQUIRED ON makes the compiler throw an error if it can't support C++98 (eliminates fallback to newer standards)
  • CMAKE_CXX_EXTENSIONS OFF disables compiler-specific non-standard syntax (like GNU extensions) that might bypass standard checks

After making these changes, reload your CMake project (click the "Reload changes" icon in the CMake tool window, or go to File > Reload CMake Project).

Next, make sure the IDE itself flags C++11+ code as you write it:

1. Open Settings/Preferences (Windows/Linux: File > Settings; Mac: CLion > Preferences)
2. Navigate to Editor > Inspections > C/C++ > General
3. Find and check the C++ standard conformity inspection
4. Expand this inspection, then in the Options section, set C++ standard to C++98
5. Also, enable the Language level mismatch inspection (under the same C/C++ > General section)—this will catch cases where your code uses features from a higher language level than configured

clang-tidy needs explicit configuration to match your C++ standard:

1. In Settings/Preferences, go to Tools > clang-tidy
2. First, ensure Enable clang-tidy is checked
3. In the Clang-tidy options field, add --std=c++98 (append it if there are existing options, separated by spaces)
4. For stricter checks, add relevant clang-tidy rules to the Checks list. For example, enable the modernize-* family of rules—these specifically flag C++11+ features like auto, range-based for loops, or initializer lists. You can set checks to something like:

   modernize-use-auto, modernize-range-for, modernize-list-initialization
   

   Or use -*,modernize-* if you want to disable default checks and only run modernization-related ones.

Test with some C11-specific code to confirm everything is enforcing C98:

#include <vector>

int main() {
    auto x = 42; // C++11 auto deduction (should be flagged)
    std::vector<int> nums = {1, 2, 3}; // C++11 initializer list (should be flagged)
    return 0;
}

You should see:

• Red squiggles under the C++11 code in the editor (from IDE inspections)
• clang-tidy warnings/errors in the clang-tidy tool window
• A compiler error when you build the project (thanks to the CMake settings)

Quick troubleshooting tips #

• If old CMake settings are stuck, delete the cmake-build-* folder in your project and rebuild
• Double-check that your compiler (GCC/Clang/MSVC) supports C++98—all modern compilers do, but some very new versions might need explicit flags (which CMake handles for you)
• If clang-tidy isn't picking up the standard, verify the path to clang-tidy in Tools > clang-tidy is correct (point to the exact executable if CLion doesn't auto-detect it)

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