全局命名空间允许同名变量的实现方式？重复变量编译未报错原因？

Great questions—let's break them down clearly, since this ties into how C++ handles linkage and compilation units!

The key here is leveraging linkage properties to isolate the variables so they don't collide. Here are two reliable ways:

• Use static for internal linkage: When you mark a global variable with static, it gets internal linkage—meaning it's only visible within its own compilation unit (the .cpp file it's defined in). You can define identical-named static globals in different .cpp files, and they'll be treated as completely separate entities.
  Example:

  // file1.cpp
  static int counter = 5; // Only exists in file1.cpp
  

  // file2.cpp
  static int counter = 10; // Only exists in file2.cpp—no conflict with file1's counter
  

• Leverage const's default internal linkage: In C++, global const variables default to internal linkage (unlike non-const globals, which are external by default). This means a const global won't be visible outside its compilation unit unless you explicitly add extern. So you can have a const global in one file and a non-const (or another const) global with the same name in another file without collision.
  Example:

  // file1.cpp
  const int max_value = 100; // Internal linkage—only visible here
  

  // file2.cpp
  int max_value = 200; // External linkage, but no conflict since file1's const isn't exposed globally
  

Compilation and linking are two separate stages, and this is where the confusion usually comes in:

• Same compilation unit: If you define two identical global variables in the same .cpp file, your compiler will absolutely throw a "redefinition" error during compilation—no way around that. This is the case you'd expect to fail.
• Different compilation units: When you compile each .cpp file separately, the compiler only sees the code in that single file. It has no idea there's a duplicate variable in another file. So each file compiles fine on its own.
  The conflict only shows up during linking—unless one or both variables have internal linkage (via static or const). If a variable has internal linkage, the linker doesn't add it to the global symbol table, so it never clashes with a variable from another unit. That's why your code might compile and link successfully even with duplicate global names.

For example, if you have a non-static, non-const global in two files, compilation will pass, but linking will fail with a "multiple definition" error. But if one is static, linking will succeed because the static variable isn't part of the global symbol pool.

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