C++模块中匿名命名空间变量地址不一致问题求助

问题描述 #

在coroutine.cpp中存在变量exception_transformers：

• 当它处于匿名命名空间时，输出显示register_exception_handler()访问的地址比其他函数的访问地址偏移0x18字节；
• 若将该变量移出匿名命名空间，则所有函数访问的地址完全一致。

请问这是否是C++模块与匿名命名空间的交互导致的问题？或是存在其他诱因？

依据C++23标准文档n4928的9.8.2.2 [namespace.unnamed]条款：

...all occurrences of unique in a translation unit are replaced by the same identifier, and this identifier differs from all other identifiers in the translation unit.

按我的理解，这表明同一翻译单元内的所有匿名命名空间行为等同于拥有相同名称，因此在同一文件的不同匿名命名空间中声明和定义transform_exception()不应引发问题。

代码示例（Clang 19） #

module;

#include <coroutine>
#include <expected>
#include <functional>
#include <iostream>
#include <ranges>
#include <stdexcept>
#include <system_error>
#include <type_traits>
#include <vector>

export module mycoroutine;
export import :stdexception;

export {
  namespace exco {
  template <typename T> using result_t = std::expected<T, std::error_code>;
  }
}

namespace {
auto transform_exception() -> exco::result_t<void>;
std::vector<std::function<exco::result_t<void>()>> exception_transformers{transform_exception};
}

export {
  namespace exco {
  auto register_exception_handler(std::function<exco::result_t<void>()> func) {
    std::cout << "register_exception_handler()" << &exception_transformers
              << ' ' << exception_transformers.size() << '\n';
    exception_transformers.emplace_back(std::move(func));
    std::cout << "register_exception_handler()" << &exception_transformers
              << ' ' << exception_transformers.size() << ' '
              << sizeof(exception_transformers) << '\n';
  }
  inline auto unerr(auto const t) {
    return std::unexpected{make_error_code(t)};
  }

  template <typename T> struct expected_wrapper {
    // Initialize as errno 0 so there are no restrictions on T
    // caused by initializing this
    exco::result_t<T> m_result{exco::unerr(static_cast<std::errc>(0))};
    expected_wrapper<T> *&m_ptr_to_this;
    expected_wrapper(expected_wrapper<T> *&ptr_to_this)
        : m_ptr_to_this{ptr_to_this} {
      m_ptr_to_this = this;
    }
    operator result_t<T>() { return std::move(m_result); };
  };
  } // namespace exco

  namespace std {
  template <typename T, typename... Args>
  struct coroutine_traits<exco::result_t<T>, Args...> {
    class promise_type;
    template <typename T1> struct awaiter_type {
      exco::result_t<T1> &m_result;
      explicit awaiter_type(exco::result_t<T1> &result) noexcept
          : m_result{result} {}
      auto await_ready() { return m_result.has_value(); }
      auto await_suspend(std::coroutine_handle<promise_type> h) {
        // This should only happen when await_ready() returns false,
        // which means that has_value() returned false.
        h.destroy();
      }
      auto await_resume() {
        // This should only happen when await_ready() returns true,
        // which means that has_value() returned true.
        return m_result.value();
      }
    };

    class promise_type {
      exco::expected_wrapper<T> *m_ptr_to_wrapper;

    public:
      auto initial_suspend() noexcept -> std::suspend_never { return {}; }
      auto final_suspend() noexcept -> std::suspend_never { return {}; }
      auto return_value(std::error_code ec) {
        m_ptr_to_wrapper->m_result = std::unexpected{ec};
      }
      auto return_value(auto &&t) { m_ptr_to_wrapper->m_result = std::move(t); }
      auto get_return_object() {
        return exco::expected_wrapper<T>{m_ptr_to_wrapper};
      }
      auto unhandled_exception() {
        for (auto &f : exception_transformers | std::views::reverse) {
          try {
            auto result = f();
            if (!result.has_value()) {
              m_ptr_to_wrapper->m_result = std::unexpected{result.error()};
              return;
            }
          } catch (...) {
          }
        }
        m_ptr_to_wrapper->m_result = exco::unerr(exco::stdexception::unknown);
      }
      template <typename T1> auto await_transform(exco::result_t<T1> value) {
        m_ptr_to_wrapper->m_result = std::move(value);
        return awaiter_type<T1>{m_ptr_to_wrapper->m_result};
      }
    };
  };
  } // namespace std
}

namespace {
auto transform_exception() -> exco::result_t<void> {
  std::cout << "transform_exception()" << &exception_transformers << ' '
            << exception_transformers.size() << '\n';
  try {
    throw;
  } catch (std::exception const &) {
    return exco::unerr(exco::stdexception::exception);
  }
}
}

原因分析与结论 #

这确实是C++模块与匿名命名空间的交互导致的问题，核心在于Clang对模块分阶段编译的实现细节：

1. 模块编译的阶段隔离：
   C++模块将代码分为全局模块片段、接口单元和实现单元。你的代码中，register_exception_handler()位于export块内（属于模块接口），而exception_transformers所在的匿名命名空间在export块外（属于模块实现）。Clang在处理模块时，会将接口代码关联的匿名命名空间和实现代码关联的匿名命名空间视为独立的作用域，生成了两个完全独立的exception_transformers实例。

2. 地址偏移的本质：
   0x18正好是64位系统下std::vector的典型大小（24字节），说明两个函数访问的是不同的对象，而非同一对象的不同偏移。

3. 标准与实现的差异：
   虽然C++标准规定同一翻译单元内的所有匿名命名空间等价于同一个唯一命名空间，但Clang的模块实现尚未完全遵循这一规则，对跨接口/实现区域的匿名命名空间实体做了隔离处理。

4. 移出匿名命名空间后的行为：
   将变量移到匿名命名空间外后，它成为模块的内部链接实体，所有函数访问的都是同一个实例，因此地址一致。

解决方案 #

• 将exception_transformers和transform_exception()统一放在同一个匿名命名空间中，且确保该命名空间位于export块之外（模块实现区域）；
• 或者使用模块内部的具名命名空间替代匿名命名空间，彻底避免模块编译阶段的作用域混淆。

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