多平台以及跨平台编译和调试相关（持续更新）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 平台检测宏定义
#if defined(_WIN32) || defined(_WIN64)
    #define PLATFORM_WINDOWS
#elif defined(__linux__)
    #define PLATFORM_LINUX
#elif defined(__APPLE__) && defined(__MACH__)
    #define PLATFORM_MACOS
#endif

// 编译器检测
#if defined(_MSC_VER)
    #define COMPILER_MSVC
#elif defined(__GNUC__)
    #define COMPILER_GCC
#elif defined(__clang__)
    #define COMPILER_CLANG
#endif

// 使用示例
void printPlatform() {
#ifdef PLATFORM_WINDOWS
    std::cout << "Running on Windows" << std::endl;
#elif defined(PLATFORM_LINUX)
    std::cout << "Running on Linux" << std::endl;
#elif defined(PLATFORM_MACOS)
    std::cout << "Running on macOS" << std::endl;
#endif
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 项目空间变量定义以及导出示例
#define _PGA ProgramA
#define _PGA_BEGIN namespace Program {
#define _PGA_END }

#ifdef __cplusplus
#define _C_START  extern "C" {
#define _CEND   }
#else
#define _C_START 
#define _CEND
#endif

#ifdef PGA_EXPORTS
#if defined(_MSC_VER)
#define _PGA_EXPORTS  __declspec(dllexport)
#else
#define _PGA_EXPORTS  __attribute__ ((visibility("default")))
#endif

#else
#if defined(_MSC_VER)
#  define _PGA_EXPORTS     __declspec(dllimport) 
#else
#  define _PGA_EXPORTS
#endif
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// export_macros.h
#ifndef EXPORT_MACROS_H
#define EXPORT_MACROS_H

// 在构建库时定义 MYLIBRARY_BUILDING_LIB
// 在使用库时不需要定义

#if defined(_WIN32) || defined(_WIN64)
    // Windows平台
    #ifdef MYLIBRARY_BUILDING_LIB
        #define MYLIBRARY_API __declspec(dllexport)
    #else
        #define MYLIBRARY_API __declspec(dllimport)
    #endif
    #define MYLIBRARY_LOCAL
#elif defined(__GNUC__) || defined(__clang__)
    // GCC和Clang编译器（Linux/macOS）
    #ifdef MYLIBRARY_BUILDING_LIB
        #define MYLIBRARY_API __attribute__((visibility("default")))
    #else
        #define MYLIBRARY_API
    #endif
    #define MYLIBRARY_LOCAL __attribute__((visibility("hidden")))
#else
    #define MYLIBRARY_API
    #define MYLIBRARY_LOCAL
#endif

// 使用示例
// 在库的头文件中：
class MYLIBRARY_API MyClass {
public:
    MYLIBRARY_API void publicFunction();
    MYLIBRARY_LOCAL void internalFunction();  // 内部函数，不导出
};

MYLIBRARY_API int globalFunction();  // 导出函数

#endif // EXPORT_MACROS_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// platform_utils.h - 统一接口
#ifndef PLATFORM_UTILS_H
#define PLATFORM_UTILS_H

#include "export_macros.h"

class MYLIBRARY_API PlatformUtils {
public:
    // 获取系统时间（高精度）
    static double getSystemTime();
    
    // 创建线程
    static void* createThread(void (*func)(void*), void* arg);
    
    // 获取当前线程ID
    static unsigned long getCurrentThreadId();
    
    // 平台特定的内存对齐分配
    static void* alignedMalloc(size_t size, size_t alignment);
    static void alignedFree(void* ptr);
};

#endif // PLATFORM_UTILS_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// platform_utils_windows.cpp - Windows实现
#ifdef _WIN32
#include "platform_utils.h"
#include <windows.h>
#include <profileapi.h>

double PlatformUtils::getSystemTime() {
    LARGE_INTEGER frequency, counter;
    QueryPerformanceFrequency(&frequency);
    QueryPerformanceCounter(&counter);
    return static_cast<double>(counter.QuadPart) / frequency.QuadPart;
}

void* PlatformUtils::createThread(void (*func)(void*), void* arg) {
    return CreateThread(nullptr, 0, 
        reinterpret_cast<LPTHREAD_START_ROUTINE>(func), 
        arg, 0, nullptr);
}

unsigned long PlatformUtils::getCurrentThreadId() {
    return GetCurrentThreadId();
}

void* PlatformUtils::alignedMalloc(size_t size, size_t alignment) {
    return _aligned_malloc(size, alignment);
}

void PlatformUtils::alignedFree(void* ptr) {
    _aligned_free(ptr);
}
#endif // _WIN32

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// platform_utils_linux.cpp - Linux实现
#ifdef __linux__
#include "platform_utils.h"
#include <pthread.h>
#include <sys/time.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <malloc.h>

double PlatformUtils::getSystemTime() {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ts.tv_sec + ts.tv_nsec * 1e-9;
}

void* PlatformUtils::createThread(void (*func)(void*), void* arg) {
    pthread_t thread;
    if (pthread_create(&thread, nullptr, 
        reinterpret_cast<void*(*)(void*)>(func), arg) == 0) {
        return reinterpret_cast<void*>(thread);
    }
    return nullptr;
}

unsigned long PlatformUtils::getCurrentThreadId() {
    return syscall(SYS_gettid);
}

void* PlatformUtils::alignedMalloc(size_t size, size_t alignment) {
    return memalign(alignment, size);
}

void PlatformUtils::alignedFree(void* ptr) {
    free(ptr);
}
#endif // __linux__

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 字符串转换（Windows使用宽字符，Linux使用UTF-8）
#ifdef _WIN32
    #include <windows.h>
    #include <stringapiset.h>
    
    std::string wideToUtf8(const std::wstring& wide) {
        int size_needed = WideCharToMultiByte(
            CP_UTF8, 0, wide.c_str(), -1, nullptr, 0, nullptr, nullptr);
        std::string str(size_needed, 0);
        WideCharToMultiByte(
            CP_UTF8, 0, wide.c_str(), -1, &str[0], size_needed, nullptr, nullptr);
        return str;
    }
    
    std::wstring utf8ToWide(const std::string& utf8) {
        int size_needed = MultiByteToWideChar(
            CP_UTF8, 0, utf8.c_str(), -1, nullptr, 0);
        std::wstring wstr(size_needed, 0);
        MultiByteToWideChar(
            CP_UTF8, 0, utf8.c_str(), -1, &wstr[0], size_needed);
        return wstr;
    }
#else
    // Linux/macOS默认使用UTF-8，不需要转换
    std::string wideToUtf8(const std::string& str) { return str; }
    std::string utf8ToWide(const std::string& str) { return str; }
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 对齐方式（C++11之前使用编译器扩展）
#if defined(_MSC_VER)
    #define ALIGNED(x) __declspec(align(x))
#elif defined(__GNUC__) || defined(__clang__)
    #define ALIGNED(x) __attribute__((aligned(x)))
#else
    #define ALIGNED(x)
#endif

// 内联函数提示
#if defined(_MSC_VER)
    #define FORCE_INLINE __forceinline
#elif defined(__GNUC__) || defined(__clang__)
    #define FORCE_INLINE __attribute__((always_inline)) inline
#else
    #define FORCE_INLINE inline
#endif

// 禁用警告
#if defined(_MSC_VER)
    #define DISABLE_WARNING_PUSH __pragma(warning(push))
    #define DISABLE_WARNING_POP __pragma(warning(pop))
    #define DISABLE_WARNING(warningNumber) __pragma(warning(disable: warningNumber))
#elif defined(__GNUC__) || defined(__clang__)
    #define DISABLE_WARNING_PUSH _Pragma("GCC diagnostic push")
    #define DISABLE_WARNING_POP _Pragma("GCC diagnostic pop")
    #define DISABLE_WARNING(warningName) _Pragma(GCC diagnostic ignored "-W" #warningName)
#else
    #define DISABLE_WARNING_PUSH
    #define DISABLE_WARNING_POP
    #define DISABLE_WARNING(warningNumber)
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// filesystem_utils.h - 跨平台文件系统接口
#ifndef FILESYSTEM_UTILS_H
#define FILESYSTEM_UTILS_H

#include <string>
#include <vector>

class FileSystem {
public:
    // 路径分隔符
    static char pathSeparator();
    
    // 路径连接
    static std::string join(const std::string& path1, const std::string& path2);
    
    // 判断路径是否存在
    static bool exists(const std::string& path);
    
    // 创建目录
    static bool createDirectory(const std::string& path);
    
    // 列出目录内容
    static std::vector<std::string> listDirectory(const std::string& path);
};

#endif // FILESYSTEM_UTILS_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// filesystem_utils.cpp - Windows实现
#ifdef PLATFORM_WINDOWS
#include <windows.h>
#include <shlwapi.h>

char FileSystem::pathSeparator() {
    return '\\';
}

std::string FileSystem::join(const std::string& path1, const std::string& path2) {
    if (path1.empty()) return path2;
    if (path2.empty()) return path1;
    
    std::string result = path1;
    if (result.back() != '\\' && result.back() != '/') {
        result += '\\';
    }
    result += path2;
    return result;
}

bool FileSystem::exists(const std::string& path) {
    DWORD dwAttrib = GetFileAttributesA(path.c_str());
    return (dwAttrib != INVALID_FILE_ATTRIBUTES);
}

bool FileSystem::createDirectory(const std::string& path) {
    return CreateDirectoryA(path.c_str(), nullptr) != 0;
}
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// filesystem_utils.cpp - Linux实现
#ifdef PLATFORM_LINUX
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h>

char FileSystem::pathSeparator() {
    return '/';
}

std::string FileSystem::join(const std::string& path1, const std::string& path2) {
    if (path1.empty()) return path2;
    if (path2.empty()) return path1;
    
    std::string result = path1;
    if (result.back() != '/') {
        result += '/';
    }
    result += path2;
    return result;
}

bool FileSystem::exists(const std::string& path) {
    struct stat buffer;
    return (stat(path.c_str(), &buffer) == 0);
}

bool FileSystem::createDirectory(const std::string& path) {
    return mkdir(path.c_str(), 0755) == 0;
}
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// thread_utils.h
#ifndef THREAD_UTILS_H
#define THREAD_UTILS_H

#include <cstdint>

class Mutex {
public:
    Mutex();
    ~Mutex();
    
    void lock();
    void unlock();
    bool tryLock();
    
private:
    void* m_impl;  // 平台特定的实现指针
};

class ConditionVariable {
public:
    ConditionVariable();
    ~ConditionVariable();
    
    void wait(Mutex& mutex);
    void notifyOne();
    void notifyAll();
    
private:
    void* m_impl;
};

#endif // THREAD_UTILS_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// dll_loader.h
#ifndef DLL_LOADER_H
#define DLL_LOADER_H

#include <string>
#include <functional>

class DynamicLibrary {
public:
    DynamicLibrary();
    ~DynamicLibrary();
    
    bool load(const std::string& path);
    void unload();
    
    template<typename T>
    T getSymbol(const std::string& name) {
        void* symbol = getSymbolImpl(name);
        return reinterpret_cast<T>(symbol);
    }
    
    bool isLoaded() const { return m_handle != nullptr; }
    
private:
    void* getSymbolImpl(const std::string& name);
    void* m_handle;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// dll_loader.cpp - Windows实现
#ifdef PLATFORM_WINDOWS
#include <windows.h>

bool DynamicLibrary::load(const std::string& path) {
    m_handle = LoadLibraryA(path.c_str());
    return m_handle != nullptr;
}

void DynamicLibrary::unload() {
    if (m_handle) {
        FreeLibrary(static_cast<HMODULE>(m_handle));
        m_handle = nullptr;
    }
}

void* DynamicLibrary::getSymbolImpl(const std::string& name) {
    if (!m_handle) return nullptr;
    return GetProcAddress(static_cast<HMODULE>(m_handle), name.c_str());
}
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// dll_loader.cpp - Linux实现
#ifdef PLATFORM_LINUX
#include <dlfcn.h>

bool DynamicLibrary::load(const std::string& path) {
    m_handle = dlopen(path.c_str(), RTLD_LAZY);
    return m_handle != nullptr;
}

void DynamicLibrary::unload() {
    if (m_handle) {
        dlclose(m_handle);
        m_handle = nullptr;
    }
}

void* DynamicLibrary::getSymbolImpl(const std::string& name) {
    if (!m_handle) return nullptr;
    return dlsym(m_handle, name.c_str());
}
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 调试宏定义
#ifdef _DEBUG
    #define DEBUG_BREAK() __debugbreak()
    #define DEBUG_PRINT(msg) OutputDebugStringA(msg)
#else
    #define DEBUG_BREAK()
    #define DEBUG_PRINT(msg)
#endif

// 条件断点
if (variable == targetValue) {
    DEBUG_BREAK();  // 条件满足时中断
}

// 断言
#include <cassert>
assert(ptr != nullptr && "Pointer should not be null");

// 自定义断言（支持格式化字符串）
#define ASSERT_MSG(condition, msg) \
    do { \
        if (!(condition)) { \
            std::cerr << "Assertion failed: " << msg << std::endl; \
            DEBUG_BREAK(); \
        } \
    } while(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// logger.h - 跨平台日志系统
#ifndef LOGGER_H
#define LOGGER_H

#include <string>
#include <fstream>
#include <memory>
#include <mutex>

enum class LogLevel {
    Debug,
    Info,
    Warning,
    Error,
    Fatal
};

class Logger {
public:
    static Logger& getInstance();
    
    void setLevel(LogLevel level);
    void setOutputFile(const std::string& filename);
    
    void log(LogLevel level, const std::string& message);
    void log(LogLevel level, const char* format, ...);
    
private:
    Logger();
    ~Logger();
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
    
    std::string levelToString(LogLevel level);
    void writeLog(LogLevel level, const std::string& message);
    
    LogLevel m_level;
    std::unique_ptr<std::ofstream> m_file;
    std::mutex m_mutex;
};

// 便捷宏
#define LOG_DEBUG(msg) Logger::getInstance().log(LogLevel::Debug, msg)
#define LOG_INFO(msg) Logger::getInstance().log(LogLevel::Info, msg)
#define LOG_WARNING(msg) Logger::getInstance().log(LogLevel::Warning, msg)
#define LOG_ERROR(msg) Logger::getInstance().log(LogLevel::Error, msg)
#define LOG_FATAL(msg) Logger::getInstance().log(LogLevel::Fatal, msg)

#endif // LOGGER_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
// logger.cpp
#include "logger.h"
#include <iostream>
#include <ctime>
#include <iomanip>
#include <sstream>

#ifdef PLATFORM_WINDOWS
#include <windows.h>
#endif

Logger& Logger::getInstance() {
    static Logger instance;
    return instance;
}

Logger::Logger() : m_level(LogLevel::Info) {
#ifdef PLATFORM_WINDOWS
    // Windows上输出到调试器
    AllocConsole();
    freopen_s((FILE**)stdout, "CONOUT$", "w", stdout);
#endif
}

void Logger::log(LogLevel level, const std::string& message) {
    if (level < m_level) return;
    
    writeLog(level, message);
}

void Logger::writeLog(LogLevel level, const std::string& message) {
    std::lock_guard<std::mutex> lock(m_mutex);
    
    auto now = std::time(nullptr);
    auto tm = *std::localtime(&now);
    
    std::ostringstream oss;
    oss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");
    std::string timestamp = oss.str();
    
    std::string logMessage = "[" + timestamp + "] [" + 
                            levelToString(level) + "] " + 
                            message + "\n";
    
    // 输出到控制台
    std::cout << logMessage;
    
    // 输出到文件
    if (m_file && m_file->is_open()) {
        *m_file << logMessage;
        m_file->flush();
    }
    
#ifdef PLATFORM_WINDOWS
    // Windows上同时输出到调试器
    OutputDebugStringA(logMessage.c_str());
#endif
}

std::string Logger::levelToString(LogLevel level) {
    switch (level) {
        case LogLevel::Debug:   return "DEBUG";
        case LogLevel::Info:    return "INFO";
        case LogLevel::Warning: return "WARNING";
        case LogLevel::Error:   return "ERROR";
        case LogLevel::Fatal:   return "FATAL";
        default:                return "UNKNOWN";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 使用C++17 filesystem库（推荐）
#include <filesystem>
namespace fs = std::filesystem;

// 跨平台路径操作
fs::path configPath = fs::path("config") / "settings.json";
std::string pathStr = configPath.string();  // 自动转换为平台格式

// 创建目录
fs::create_directories("logs/2025/09");

// 遍历目录
for (const auto& entry : fs::directory_iterator(".")) {
    if (entry.is_regular_file()) {
        std::cout << entry.path() << std::endl;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// Windows上处理中文路径（使用宽字符API）
#ifdef _WIN32
#include <windows.h>
#include <string>
#include <locale>
#include <codecvt>

// UTF-8字符串转宽字符（Windows API需要）
std::wstring utf8ToWstring(const std::string& utf8) {
    if (utf8.empty()) return std::wstring();
    
    int size_needed = MultiByteToWideChar(
        CP_UTF8, 0, utf8.c_str(), -1, nullptr, 0);
    if (size_needed <= 0) return std::wstring();
    
    std::wstring wstr(size_needed, 0);
    MultiByteToWideChar(
        CP_UTF8, 0, utf8.c_str(), -1, &wstr[0], size_needed);
    return wstr;
}

// 宽字符转UTF-8字符串
std::string wstringToUtf8(const std::wstring& wstr) {
    if (wstr.empty()) return std::string();
    
    int size_needed = WideCharToMultiByte(
        CP_UTF8, 0, wstr.c_str(), -1, nullptr, 0, nullptr, nullptr);
    if (size_needed <= 0) return std::string();
    
    std::string str(size_needed, 0);
    WideCharToMultiByte(
        CP_UTF8, 0, wstr.c_str(), -1, &str[0], size_needed, nullptr, nullptr);
    return str;
}

// 使用宽字符API打开中文路径文件
bool openChinesePathFile(const std::string& utf8Path) {
    std::wstring wpath = utf8ToWstring(utf8Path);
    HANDLE hFile = CreateFileW(
        wpath.c_str(),
        GENERIC_READ,
        FILE_SHARE_READ,
        nullptr,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        nullptr
    );
    
    if (hFile != INVALID_HANDLE_VALUE) {
        CloseHandle(hFile);
        return true;
    }
    return false;
}
#endif

1
2
3
4
5
6
7
8
9
10
11
// Linux/macOS默认使用UTF-8，可以直接处理中文路径
#if defined(__linux__) || defined(__APPLE__)
#include <fstream>
#include <filesystem>

// Linux/macOS直接使用UTF-8路径即可
bool openChinesePathFile(const std::string& utf8Path) {
    std::ifstream file(utf8Path);
    return file.good();
}
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
// chinese_path_utils.h
#ifndef CHINESE_PATH_UTILS_H
#define CHINESE_PATH_UTILS_H

#include <string>
#include <filesystem>

#ifdef _WIN32
#include <windows.h>
#include <io.h>
#include <fcntl.h>
#endif

class ChinesePathUtils {
public:
    // 确保控制台支持UTF-8输出（Windows需要特殊处理）
    static void setupConsoleUTF8() {
#ifdef _WIN32
        // 设置控制台代码页为UTF-8
        SetConsoleOutputCP(CP_UTF8);
        SetConsoleCP(CP_UTF8);
        
        // 设置stdout/stdin为UTF-8模式
        _setmode(_fileno(stdout), _O_U8TEXT);
        _setmode(_fileno(stdin), _O_U8TEXT);
        _setmode(_fileno(stderr), _O_U8TEXT);
#endif
        // Linux/macOS默认UTF-8，无需设置
    }
    
    // 使用filesystem库处理中文路径（C++17，推荐方法）
    static bool existsUtf8(const std::string& utf8Path) {
        try {
            std::filesystem::path path(utf8Path);
            return std::filesystem::exists(path);
        } catch (const std::exception& e) {
            return false;
        }
    }
    
    // 打开UTF-8路径的文件流
    static std::ifstream openUtf8File(const std::string& utf8Path) {
#ifdef _WIN32
        // Windows上需要转换为宽字符路径
        std::wstring wpath = utf8ToWstring(utf8Path);
        return std::ifstream(wpath);
#else
        // Linux/macOS直接使用UTF-8
        return std::ifstream(utf8Path);
#endif
    }
    
#ifdef _WIN32
private:
    static std::wstring utf8ToWstring(const std::string& utf8) {
        if (utf8.empty()) return std::wstring();
        int size_needed = MultiByteToWideChar(
            CP_UTF8, 0, utf8.c_str(), -1, nullptr, 0);
        if (size_needed <= 0) return std::wstring();
        std::wstring wstr(size_needed, 0);
        MultiByteToWideChar(
            CP_UTF8, 0, utf8.c_str(), -1, &wstr[0], size_needed);
        return wstr;
    }
#endif
};

#endif // CHINESE_PATH_UTILS_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#include <filesystem>
#include <iostream>
#include <fstream>
#include <locale>
#include <codecvt>

namespace fs = std::filesystem;

// 设置UTF-8 locale（在某些系统上可能需要）
void setupUtf8Locale() {
#ifdef _WIN32
    // Windows上设置控制台UTF-8
    system("chcp 65001 > nul");
    SetConsoleOutputCP(CP_UTF8);
#endif
    // 设置全局locale（可选）
    try {
        std::locale::global(std::locale("en_US.UTF-8"));
    } catch (...) {
        // 如果locale不可用，使用默认locale
    }
}

// 处理中文路径的完整示例
void handleChinesePath(const std::string& chinesePath) {
    setupUtf8Locale();
    
    try {
        // 使用filesystem::path，它会自动处理编码
        fs::path path(chinesePath);
        
        // 检查路径是否存在
        if (fs::exists(path)) {
            std::cout << "路径存在: " << path << std::endl;
            
            // 如果是目录，遍历内容
            if (fs::is_directory(path)) {
                for (const auto& entry : fs::directory_iterator(path)) {
                    std::cout << "  " << entry.path().filename() << std::endl;
                }
            }
            
            // 如果是文件，读取内容
            if (fs::is_regular_file(path)) {
#ifdef _WIN32
                // Windows上需要特殊处理
                std::wifstream file(path.wstring());
                if (file.is_open()) {
                    file.imbue(std::locale(file.getloc(), 
                        new std::codecvt_utf8<wchar_t>));
                    std::wstring line;
                    while (std::getline(file, line)) {
                        // 处理文件内容
                    }
                    file.close();
                }
#else
                // Linux/macOS直接使用UTF-8
                std::ifstream file(path);
                std::string line;
                while (std::getline(file, line)) {
                    // 处理文件内容
                }
                file.close();
#endif
            }
        } else {
            std::cout << "路径不存在: " << path << std::endl;
        }
    } catch (const fs::filesystem_error& e) {
        std::cerr << "文件系统错误: " << e.what() << std::endl;
    }
}

// 示例：创建中文路径的目录
bool createChineseDirectory(const std::string& utf8Path) {
    try {
        fs::path dirPath(utf8Path);
        return fs::create_directories(dirPath);
    } catch (const std::exception& e) {
        std::cerr << "创建目录失败: " << e.what() << std::endl;
        return false;
    }
}

1
2
3
4
5
6
7
8
9
10
// 在代码中确保字符串字面量使用UTF-8编码
// 方法1：使用u8前缀（C++11）
const char* path = u8"中文路径/文件.txt";

// 方法2：确保源文件保存为UTF-8编码（推荐）
const std::string path = "中文路径/文件.txt";

// 方法3：使用原始字符串（C++11）
const std::string path = R"(中文路径\文件.txt)";  // Windows路径
const std::string path = R"(中文路径/文件.txt)";  // Unix路径

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// config.h - 统一配置管理
#ifndef CONFIG_H
#define CONFIG_H

// 平台定义
#if defined(_WIN32) || defined(_WIN64)
    #define PLATFORM_WINDOWS 1
    #ifndef PLATFORM_LINUX
        #define PLATFORM_LINUX 0
    #endif
    #ifndef PLATFORM_MACOS
        #define PLATFORM_MACOS 0
    #endif
#elif defined(__linux__)
    #define PLATFORM_WINDOWS 0
    #define PLATFORM_LINUX 1
    #define PLATFORM_MACOS 0
#elif defined(__APPLE__)
    #define PLATFORM_WINDOWS 0
    #define PLATFORM_LINUX 0
    #define PLATFORM_MACOS 1
#endif

// 特性检测
#if defined(__cpp_lib_filesystem) || (defined(_MSC_VER) && _MSC_VER >= 1914)
    #define HAS_STD_FILESYSTEM 1
#else
    #define HAS_STD_FILESYSTEM 0
#endif

#endif // CONFIG_H

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// error_code.h - 统一错误码
enum class ErrorCode {
    Success = 0,
    FileNotFound,
    PermissionDenied,
    NetworkError,
    InvalidParameter,
    OutOfMemory,
    PlatformSpecificError = 1000  // 平台特定错误从此开始
};

class SystemError {
public:
    SystemError(ErrorCode code, const std::string& message)
        : m_code(code), m_message(message) {}
    
    ErrorCode code() const { return m_code; }
    const std::string& message() const { return m_message; }
    
    // 获取平台特定的错误码
    int platformCode() const;
    
private:
    ErrorCode m_code;
    std::string m_message;
};

// 错误码转换
ErrorCode getLastError() {
#ifdef PLATFORM_WINDOWS
    DWORD error = GetLastError();
    switch (error) {
        case ERROR_FILE_NOT_FOUND:
            return ErrorCode::FileNotFound;
        case ERROR_ACCESS_DENIED:
            return ErrorCode::PermissionDenied;
        default:
            return ErrorCode::PlatformSpecificError;
    }
#else
    int error = errno;
    switch (error) {
        case ENOENT:
            return ErrorCode::FileNotFound;
        case EACCES:
            return ErrorCode::PermissionDenied;
        default:
            return ErrorCode::PlatformSpecificError;
    }
#endif
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// test/test_filesystem.cpp
#include <gtest/gtest.h>
#include "filesystem_utils.h"

TEST(FileSystemTest, PathSeparator) {
#ifdef PLATFORM_WINDOWS
    EXPECT_EQ(FileSystem::pathSeparator(), '\\');
#else
    EXPECT_EQ(FileSystem::pathSeparator(), '/');
#endif
}

TEST(FileSystemTest, PathJoin) {
    std::string result = FileSystem::join("path1", "path2");
    EXPECT_FALSE(result.empty());
}