避免 C++ 中的歧義

Question

我正在嘗試在我的 C 項目旁邊實現一個 C++ 包裝器。

因此，例如，我有"window.h" ，它具有標准的 C 包括防護。 它需要<stdlib.h>和<string.h>以及一些第三方庫包括。

然后，我有依賴於 "window.h "window.hpp"的"window.h" ，但使用 C++ #pragma once並且需要<cstdlib>和<string>用於 C++ 實現。

我遇到了一個模棱兩可的問題，其中 C/C++ 標准實現存在沖突，我不太確定該怎么做。 你可以看到我試圖通過簡單地檢查是否定義了__cplusplus來解決這個問題，如果是這樣的話，只添加 C++ 頭文件。

這個想法是你可以using namespace LittleEngine::utils; 它將為您包括 SDL 和 GLEW，並添加一些用於創建 window 的包裝器功能，例如； 它使用 C++ 特性（如類）而不是 C 實現的方法。

為了理智，這就是為什么這些是單獨的文件，而不僅僅是一個 header 文件，它增加了對 C 和 C++ 與extern "C" {... }的兼容性。

“窗口.h”

#if __cplusplus
#pragma once
#endif

#ifndef LITTLE_ENGINE_UTILS_WINDOW_H_
#define LITTLE_ENGINE_UTILS_WINDOW_H_

#include <SDL2/SDL.h>
#include <GL/glew.h>

#if __cplusplus
#   include <cstdio>
#   include <string>
#else
#   include <stdio.h>
#   include <string.h>
#endif

typedef struct {
    SDL_Window* window;
    SDL_GLContext context;
    SDL_Event event;
} Engine_GLWindow_t;

enum Engine_Window_Renderer {
    VULKAN,
    OPENGL
};

int Engine_CreateGLWindow(const char* title, Engine_GLWindow_t* window)
{
    // Initialize SDL
    if(SDL_Init(SDL_INIT_EVERYTHING) != 0)
    {
        fprintf(stderr, "Failed to initialize SDL.\n");
        fprintf(stderr, "%s\n", SDL_GetError());
        return -1;
    }

    // Configure window flags
    Uint32 flags = 0;

    flags |= SDL_WINDOW_OPENGL;

    SDL_Window* sdlwin = SDL_CreateWindow(
        title,
        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
        800,
        600,
        flags
    );

    if(!sdlwin)
        return -1;

    window->window = sdlwin;

    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 6);
    SDL_GL_SetSwapInterval(1);

    SDL_GLContext context;
    if((context = SDL_GL_CreateContext(window->window)) != NULL)
        window->context = context;
    else
    {
        SDL_DestroyWindow(window->window);
        fprintf(stderr, "Failed to initialize the GL context.\n");
        fprintf(stderr, "%s\n", SDL_GetError());
        return -1;
    }

    glewExperimental = GL_TRUE;

    GLenum glewCode = glewInit();

    if(glewCode != GLEW_OK)
    {
        SDL_GL_DeleteContext(window->context);
        SDL_DestroyWindow(window->window);
        fprintf(stderr, "Failed to initialize GLEW.\n");
        fprintf(stderr, "%s\n", glewGetErrorString(glewCode));
        return -1;
    }

    glEnable(GL_DEPTH_TEST);

    glViewport(0, 0, 800, 600);

    SDL_ShowWindow(sdlwin);
    
    return 0;
}

int Engine_DestroyGLWindow(Engine_GLWindow_t* window)
{
    SDL_GL_DeleteContext(window->context);
    SDL_DestroyWindow(window->window);
    SDL_Quit();

    return 0;
}
#endif

“windows.hpp”

#pragma once

/*
file included as:
engine.hpp
...
namespace LittleEngine {
    namespace utils {
#       include "utils.hpp" // -> #include "windows.hpp"
    }
}
*/

#include "window.h"

#include <cstdint>

class GLWindow {
public:

    GLWindow(std::string title)
    {
        Engine_CreateGLWindow(title.c_str(), &this->window_data);
    }

    GLWindow(std::string title, bool& success)
    {
        if(Engine_CreateGLWindow(title.c_str(), &this->window_data) == 0)
            success = true;
    }

    ~GLWindow()
    {
        Engine_DestroyGLWindow(&this->window_data);
    }

    Engine_GLWindow_t* getWindowData()
    {
        return &this->window_data;
    }

protected:
    Engine_GLWindow_t window_data;
};

主文件

#include <LittleEngine/engine.hpp>

int main(int argc, char* argv[], char* envp[])
{
    // COMMENTED CODE WORKS BTW
    // Engine_GLWindow_t window;
    // Engine_CreateGLWindow("LittleBird", &window);

    LittleEngine::utils::GLWindow window("LittleBird");

    bool should_run = true;
    const LittleEngine::utils::Uint8* keys = nullptr;
    
    while (should_run)
    {
        while (LittleEngine::utils::SDL_PollEvent(&window.getWindowData()->event))
            if (window.getWindowData()->event.type == LittleEngine::utils::SDL_QUIT)
                should_run = false;

        // ensure that SDL2 updated the keyboard state
        LittleEngine::utils::SDL_PumpEvents();

        // // automatically update window size
        // UpdateWindowSize(&window);

        // SDL2 should automatically clear this memory after each loop
        keys = LittleEngine::utils::SDL_GetKeyboardState(0);

        // black background color
        LittleEngine::utils::glClearColor(0.00f, 0.00f, 0.00f, 1.00f);

        // red background color if pressing W
        if(keys[LittleEngine::utils::SDL_SCANCODE_W])
            LittleEngine::utils::glClearColor(1.00f, 0.00f, 0.00f, 1.00f);
        
        LittleEngine::utils::glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        LittleEngine::utils::SDL_GL_SwapWindow(window.getWindowData()->window);
    }
    return 0;
}

Answer 1

因此，經過更多測試后，我的問題的答案是，您必須先將 C header 文件包裝在extern "C"中，然后再嘗試將它們包含到命名空間中。

namespace LittleEngine {
    namespace utils {
        extern "C" {
#           include "window.h"
        }
#       include "window.hpp"
    }
}

但是，即使這樣做，它仍然將 C-defines 放在根名稱空間中，我想這是有道理的。

編輯：此外，它確實比這更奇怪。 在上面的例子中，我可以通過 extern-C 包含“window.h”文件。 第二個我跳到另一個文件並嘗試鏈接 impl。 這個，我得到了與我開始時相同的錯誤。 TLDR； 僅 TIL C++ 在命名空間中包含 go。

編輯 2：我認為這只是 GLEW 和 SDL 造成的問題。 我討厭編程。 我為什么要這樣對自己？

編輯3：經過更多測試..我認為是。 所以我在重構時所做的最大改變是

1. 不包括子頭文件中的頭文件。 您可以這樣做是因為 Linker 的工作原理。
2. 我取出了所有的extern "C" ，因為理論上應該做的就是禁用 C++ 名稱爭論，這無論如何都沒有意義。
3. 我只是將 SDL 和 GLEW 包含在命名空間的 scope 之外，突然它就可以工作了。

不管怎樣，我的觀點仍然成立。 不要在 C++ 命名空間中包含 C 標頭。

如果其他人想以更詳細的方式回答這個問題，我很樂意將其標記為答案。