C++20 编译失败

[hchunhui]

Describe the bug
librime-lua 收到一个报告，用 -std=c++20 编译失败：
hchunhui/librime-lua#427

经分析实际上应该是 librime rime/common.h 中一处与 C++20 不兼容。

To Reproduce
最小复现样例：

#include <iostream>
#include <filesystem>

class path : public std::filesystem::path {
  // from rime/common.h:130
  friend std::ostream& operator<<(std::ostream& os, const path& p) {
    return os << p.u8string();
  }
};

环境：

gcc (Debian 14.2.0-19) 14.2.0
Copyright (C) 2024 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

编译命令：

g++ -std=c++20 foo.cc

报错：

foo.cc: In function ‘std::ostream& operator<<(std::ostream&, const path&)’:
foo.cc:7:15: error: no match for ‘operator<<’ (operand types are ‘std::ostream’ {aka ‘std::basic_ostream<char>’} and ‘std::u8string’ {aka ‘std::__cxx11::basic_string<char8_t>’})
    7 |     return os << p.u8string();
      |            ~~ ^~ ~~~~~~~~~~~~
      |            |               |
      |            |               std::u8string {aka std::__cxx11::basic_string<char8_t>}
      |            std::ostream {aka std::basic_ostream<char>}

[fxliang]

这样可解

diff --git a/src/rime/common.h b/src/rime/common.h
index 01f068e8..24d61c38 100644
--- a/src/rime/common.h
+++ b/src/rime/common.h
@@ -26,6 +26,10 @@
 
 #ifdef RIME_ENABLE_LOGGING
 #include <glog/logging.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
 #else
 #include "no_logging.h"
 #endif  // RIME_ENABLE_LOGGING
@@ -104,6 +108,26 @@ class path : public std::filesystem::path {
   path& operator/=(const std::string& p) { return *this /= path(p); }
   path& operator/=(const char* p) { return *this /= path(p); }
 
+  std::string utf8string() const {
+#ifdef _WIN32
+    // Use Windows API for UTF-16 -> UTF-8
+    auto wstr = this->wstring();
+    if (wstr.empty()) {
+      return std::string{};
+    }
+    int cb_utf8 = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, nullptr, 0,
+                                      nullptr, nullptr);
+    if (cb_utf8 <= 1) {  // only null terminator
+      return std::string{};
+    }
+    std::string result(cb_utf8 - 1, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &result[0], cb_utf8,
+                        nullptr, nullptr);
+    return result;
+#else
+    return this->string();
+#endif
+  }
   friend path operator/(const path& lhs, const path& rhs) {
     return path(lhs) /= rhs;
   }
@@ -128,7 +152,7 @@ class path : public std::filesystem::path {
   }
 #ifdef RIME_ENABLE_LOGGING
   friend std::ostream& operator<<(std::ostream& os, const path& p) {
-    return os << p.u8string();
+    return os << p.utf8string();
   }
 #endif
 };

测试u8.cpp

#include <iostream>
#include <filesystem>
#ifdef _WIN32
#include <windows.h>
inline unsigned int SetConsoleOutputCodePage(unsigned int codepage = CP_UTF8) {
  unsigned int cp = GetConsoleOutputCP();
  SetConsoleOutputCP(codepage);
  return cp;
}
#else
inline unsigned int SetConsoleOutputCodePage(unsigned int codepage = 65001) {
  return 0;
}
#endif

class path : public std::filesystem::path {

  using fs_path = std::filesystem::path;

 public:
  path() : fs_path() {}
  path(const fs_path& p) : fs_path(p) {}
  path(fs_path&& p) : fs_path(std::move(p)) {}
#ifdef _WIN32
  // convert utf-8 string to native encoding path.
  explicit path(const std::string& utf8_path)
      : fs_path(std::filesystem::u8path(utf8_path)) {}
  explicit path(const char* utf8_path)
      : fs_path(std::filesystem::u8path(utf8_path)) {}
#else
  // disable implicit conversion from string to path for development purpose.
  explicit path(const std::string& utf8_path) : fs_path(utf8_path) {}
  explicit path(const char* utf8_path) : fs_path(utf8_path) {}
#endif

  path& operator/=(const path& p) { return *this = fs_path::operator/=(p); }
  path& operator/=(const fs_path& p) { return *this = fs_path::operator/=(p); }
  // convert UTF-8 encoded string to native encoding, then append.
  path& operator/=(const std::string& p) { return *this /= path(p); }
  path& operator/=(const char* p) { return *this /= path(p); }
  std::string utf8string() const {
#ifdef _WIN32
    // Use Windows API for UTF-16 -> UTF-8
    auto wstr = this->wstring();
    if (wstr.empty()) {
      return std::string{};
    }
    int cb_utf8 = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, nullptr, 0, nullptr, nullptr);
    if (cb_utf8 <= 1) { // only null terminator
      return std::string{};
    }
    std::string result(cb_utf8 - 1, '\0');
    WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &result[0], cb_utf8, nullptr, nullptr);
    return result;
#else
    return this->string();
#endif
  }
  // from rime/common.h:130
  friend std::ostream& operator<<(std::ostream& os, const path& p) {
    return os << p.utf8string();
  }
};

int main() {
  auto cp = SetConsoleOutputCodePage();
  path p("例子/测试.txt");
  std::cout << "Path: " << p << std::endl;
  SetConsoleOutputCodePage(cp);
  return 0;
}

linux 测试编译 gcc version 13.3.0 (Ubuntu 13.3.0-6ubuntu2~24.04)
g++ -std=c++20 u8.cpp -o u8

Windows 测试编译

mingw gcc version 14.2.0 (MinGW-W64 x86_64-msvcrt-posix-seh, built by Brecht Sanders, r3)
g++ -std=c++20 -static .\u8.cpp -o u8.exe

cl Microsoft (R) C/C++ Optimizing Compiler Version 19.41.34123 for x64
cl u8.cpp /std:c++20 /EHsc