如何让C预处理器LOOKUP宏对不存在的键返回指定常量？

Hey there, let's tackle this preprocessor challenge. The goal is to make your lookup macro return "undefined" for any missing keys, while ensuring those unused key names never make it into the compiled binary or even get seen by the compiler. Your original setup works for existing keys, but falls short on missing ones—let's fix that.

First, let's start with a clean, working solution that meets all your requirements, then break down how it works.

Final Working Code (Cleanest Version) #

#include <iostream>
// Generated header defines these (keep as-is):
#define KEY_a valueA
#define KEY_b valueB

// Helper macros for stringification (reused from your original code)
#define QUOTE_(_str_) #_str_
#define EXPAND_AND_QUOTE_(_str_) QUOTE_(_str_)

// Core dispatch logic: picks value or fallback based on key existence
#define _LOOKUP_DISPATCH_(_key_, _exists_flag_) \
    _LOOKUP_DISPATCH_##_exists_flag_(_key_)
#define _LOOKUP_DISPATCH_1(_key_) EXPAND_AND_QUOTE_(KEY_ ## _key_) // Key exists: use its value
#define _LOOKUP_DISPATCH_0(_key_) "undefined" // Key missing: return fallback

// Main lookup macro with warning suppression
#define LOOKUP(_key_) \
    _Pragma("GCC diagnostic push") \
    _Pragma("GCC diagnostic ignored \"-Wundef\"") \
    _LOOKUP_DISPATCH_(_key_, defined(KEY_ ## _key_)) \
    _Pragma("GCC diagnostic pop")

int main() {
    std::cout << LOOKUP(a) << std::endl; // Outputs: valueA
    std::cout << LOOKUP(b) << std::endl; // Outputs: valueB
    std::cout << LOOKUP(c) << std::endl; // Outputs: undefined
    std::cout << LOOKUP(whatever) << std::endl; // Outputs: undefined
}

How This Solves Your Problem #

Let's walk through the key parts to understand why this works exactly as you need:

1. Key Existence Check
   The defined(KEY_ ## _key_) part checks if the generated macro (like KEY_a) exists during preprocessing. The token concatenation ## combines KEY_ with your input key to form the full macro name.

2. Conditional Dispatch (No Dead Code)
   Instead of using a C-style ternary operator (which leaves dead code for missing keys), we use macro dispatch. The _LOOKUP_DISPATCH_ macro uses the result of defined() (1 for existing, 0 for missing) to pick either the value macro or the fallback.

   • For existing keys: It expands to EXPAND_AND_QUOTE_(KEY_a) → which becomes "valueA" (just like your original logic).
   • For missing keys: It directly expands to "undefined"—no trace of the original key name (like c or whatever) is ever generated in the preprocessed output.

3. Warning Suppression
   Most compilers (GCC, Clang) warn when you use defined() on an undefined identifier. The _Pragma lines temporarily disable the -Wundef warning just for this macro expansion, then re-enable it afterward. This keeps your build clean without turning off warnings globally.

Verify It's Working #

If you run preprocessing (e.g., g++ -E your_file.cpp), you'll see the output looks like this—no sign of KEY_c or whatever:

#include <iostream>

int main() {
    std::cout << "valueA" << std::endl;
    std::cout << "valueB" << std::endl;
    std::cout << "undefined" << std::endl;
    std::cout << "undefined" << std::endl;
}

This means the compiler never sees the missing key names, and they won't appear in the final binary at all.

Compiler Compatibility Notes #

• This works with GCC, Clang, and MSVC. For MSVC, replace the GCC pragmas with:

  _Pragma("warning(push)")
  _Pragma("warning(disable:4668)")
  // ... macro logic ...
  _Pragma("warning(pop)")
  

• _Pragma is standard C++11 and later—if you need to support older compilers, you can use compiler-specific #pragma lines directly, but _Pragma is cleaner for embedding in macros.

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