Forem: Stukdee_Gorye

为c++配置opengl编程环境

Stukdee_Gorye — Sat, 14 Feb 2026 03:39:04 +0000

为c++配置opengl编程环境

下载GLFW源码

官网：https://www.glfw.org/download.html

点击Source package按钮下载源码。

下载GLAD源码

下载地址：https://glad.dav1d.de/

语言（Language）选择“C/C++”。
API的gl选项中，选择“Version 3.3”。
模式（Profile）选择“Core”。
勾选生成加载器（Generate a loader）。

点击生成（Generate）按钮生成。

在生成后提供的新页面中点击glad.zip下载。

测试环境

目录结构：

.
|____CMakeLists.txt
|____third_party
| |____glad
| |____glfw
|____build
|____main.cpp

CMake项目配置：

cmake_minimum_required(VERSION 3.10)
project(Main)

set(CMAKE_CXX_STANDARD 14)

# 1. 添加GLAD的头文件路径
include_directories(third_party/glad/include)

# 2. 添加GLFW作为子项目并构建
set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
add_subdirectory(third_party/glfw)

# 3. 将GLAD的源文件（glad.c）添加到可执行文件的构建中
add_executable(${PROJECT_NAME} main.cpp third_party/glad/src/glad.c)

# 4. 链接GLFW库
target_link_libraries(${PROJECT_NAME} glfw)

# 5. 根据不同平台链接相应的库和框架
if(APPLE)
    # macOS平台：链接必要的框架
    target_link_libraries(${PROJECT_NAME} "-framework OpenGL")
    target_link_libraries(${PROJECT_NAME} "-framework Cocoa")
    target_link_libraries(${PROJECT_NAME} "-framework IOKit")
    target_link_libraries(${PROJECT_NAME} "-framework CoreVideo")
    # macOS平台静态链接选项（注意：macOS系统框架通常不支持完全静态链接）
    # target_link_options(${PROJECT_NAME} PRIVATE -static-libgcc -static-libstdc++)
elseif(WIN32)
    # Windows平台：链接OpenGL库
    target_link_libraries(${PROJECT_NAME} opengl32)
    # Windows可能还需要链接其他必要的系统库
    target_link_libraries(${PROJECT_NAME} gdi32 user32 shell32)
    # 添加静态链接选项
    target_link_options(${PROJECT_NAME} PRIVATE -static)
else()
    # Linux或其他平台
    find_package(OpenGL REQUIRED)
    target_link_libraries(${PROJECT_NAME} OpenGL::GL)
    # Linux平台静态链接选项（注意：某些Linux系统库可能不支持完全静态链接）
    #target_link_options(${PROJECT_NAME} PRIVATE -static-libgcc -static-libstdc++)
endif()

测试代码：

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
void framebuffer_size_callback(GLFWwindow* window,int width,int height){
    glViewport(0,0,width,height);
}
void processInput(GLFWwindow *window){
    if(glfwGetKey(window,GLFW_KEY_ESCAPE) == GLFW_PRESS){
        glfwSetWindowShouldClose(window,true);
    }
}
const char *vertexShaderSource =
    "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "void main(){\n"
    "   gl_Position = vec4(aPos.x,aPos.y,aPos.z,1.0);\n"
    "}\0";
const char *fragmentShaderSource =
    "#version 330 core\n"
    "out vec4 FragColor;\n"
    "void main(){\n"
    "   FragColor = vec4(1.0f,0.5f,0.2f,1.0f);\n"
    "}\0";
float vertices[] = {
    -0.5f,-0.5f,0.0f,
    0.5f,-0.5f,0.0f,
    0.0f,0.5f,0.0f
};
int main(){
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,3);
    glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);
    #ifdef __APPLE__
        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT,GL_TRUE);
    #endif
    GLFWwindow* window = glfwCreateWindow(800,600,"hello",NULL,NULL);
    if(window == NULL){
        printf("无法创建GLFW窗口\n");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window,framebuffer_size_callback);
    if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)){
        printf("GLAD失败\n");
        return -1;
    }
    unsigned int vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader,1,&vertexShaderSource,NULL);
    glCompileShader(vertexShader);
    unsigned int fragmentShader;
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader,1,&fragmentShaderSource,NULL);
    glCompileShader(fragmentShader);
    unsigned int shaderProgram;
    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram,vertexShader);
    glAttachShader(shaderProgram,fragmentShader);
    glLinkProgram(shaderProgram);
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    unsigned int VBO,VAO;
    glGenVertexArrays(1,&VAO);
    glGenBuffers(1,&VBO);
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER,VBO);
    glBufferData(GL_ARRAY_BUFFER,sizeof(vertices),vertices,GL_STATIC_DRAW);
    glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,3 * sizeof(float),(void*)0);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER,0);
    glBindVertexArray(0);
    while(!glfwWindowShouldClose(window)){
        processInput(window);
        glClearColor(0.0f,0.0f,0.0f,1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        glUseProgram(shaderProgram);
        glBindVertexArray(VAO);
        glDrawArrays(GL_TRIANGLES,0,3);
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    glDeleteVertexArrays(1,&VAO);
    glDeleteBuffers(1,&VBO);
    glDeleteProgram(shaderProgram);
    glfwTerminate();
    return 0;
}

编译并运行代码

在终端，移动到build文件夹中，运行如下命令：

cmake ..

Windows系统的指令需要改进成这样：

cmake -G "MinGW Makefiles" ..

运行之后会创建Makefile文件。

然后运行如下命令：

make

Windows系统如果提示没有make指令，就运行这个：

mingw32-make

在build文件夹中，可以看到Main可执行文件，点击运行后如果出现如下窗口，则环境配置成功：

C语言文件读取问题即解决方法

Stukdee_Gorye — Sun, 01 Feb 2026 12:48:11 +0000

C语言文件读取问题

在使用C语言读取相对路径下的文件时，可能会遇到“无法找到文件的问题”。

测试环境：

系统:

gcc:

Apple clang version 14.0.0 (clang-1400.0.29.202)
Target: x86_64-apple-darwin22.2.0
Thread model: posix
InstalledDir: /Library/Developer/CommandLineTools/usr/bin

目录结构：

.
|____.DS_Store
|____a.c
|____a.txt

测试：

#include <stdio.h>
int main(){
    char text[20];
    if(freopen("./a.txt","r",stdin) == NULL){
        perror("无法打开文件");
    }
    else{
        if(fgets(text,sizeof(text),stdin) == NULL){
            printf("文件读取失败\n");
            return 1;
        }
        fclose(stdin);
        printf("%s\n",text);
    }
    return 0;
}

在两种不同的运行方式下，代码运行的结果不同：

在终端且在可执行文件的目录下编译并运行文件：

可以看到文件读取成功。

但如果直接双击或在主目录（又或是除可执行文件所在的其它目录）下运行已经编译的文件：

这是双击文件时终端所显示的

这是在主目录下运行终端所显示的

根据终端输出的内容，代码读取文本失败。

原因探究

我将通过一段代码，输出程序所操作的目录（或者有其它更容易理解的称呼）。

#include <stdio.h>
#include <unistd.h>
#include <limits.h>
int main(){
    char cwd[PATH_MAX];
    if (getcwd(cwd,sizeof(cwd)) != NULL) {
        printf("当前目录: %s\n", cwd);
    } else {
        perror("getcwd()失败");
    }
    return 0;
}

再次按照先前的方式运行文件：

在其它目录下运行：

由此可见，代码所操作的目录，是终端所在的目录（或称之为终端所操作的目录），代码所读取文件的情况会因此而改变。

解决方法

可以直接获取文件的绝对路径：

这是适用于macOS的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h> /*提供PATH_MAX。*/
#include <mach-o/dyld.h> /*提供_NSGetExecutablePath*/
#include <libgen.h> /*提供dirname (optional)*/
#include <unistd.h>
char *concatenate(const char *str1,const char *str2){ /*字符拼接*/
    size_t len1 = strlen(str1);
    size_t len2 = strlen(str2);
    char *result = (char*)malloc(len1 + len2 + 1);
    if(result == NULL){
        return NULL;
    }
    strcpy(result,str1);
    strcat(result,str2);
    return result;
}
char *the_path(){ /*macOS获取绝对路径的核心代码*/
    char path[PATH_MAX];
    uint32_t size = sizeof(path);
    char *real_path = NULL;
    char *dir_path = NULL;
    if(_NSGetExecutablePath(path,&size) == 0){ /*macOS特供函数*/
        printf("获取路径为：%s\n",path);
        real_path = realpath(path,NULL); /*规范路径格式*/
        if(real_path != NULL){
            printf("绝对路径为：%s\n",real_path);
            dir_path = strdup(real_path);
            if(dir_path != NULL){ /*只获取路径*/
                char *last_slash = strrchr(dir_path, '/');
                if(last_slash != NULL){
                    *last_slash = '\0';
                }
                printf("目录路径为：%s\n",dir_path);
            }
        }
        else{
            perror("realpath");
        }
    }
    else{
        fprintf(stderr,"缓冲太小，需要 %u bytes\n",size);
    }
    if(dir_path != NULL){
        free(real_path);
        return dir_path;
    }
    return NULL;
}
int main(){
    char cwd[PATH_MAX];
    if (getcwd(cwd,sizeof(cwd)) != NULL) {
        printf("当前目录: %s\n", cwd);
    } else {
        perror("getcwd()失败");
    }
    char text[20];
    if(freopen(concatenate(the_path(),"/a.txt"),"r",stdin) == NULL){
        perror("无法打开文件");
    }
    else{
        if(fgets(text,sizeof(text),stdin) == NULL){
            printf("文件读取失败\n");
            return 1;
        }
        fclose(stdin);
        printf("%s\n",text);
    }
    return 0;
}

再次通过不同方式运行：

文件读取成功，但是这只支持macOS，所以接下来我尝试在linux下实现。

Linux获取绝对路径

我将在Termius上远程控制我的树莓派，这是我的测试环境：

接下来我来创建一下与先前一致的测试目录：

a.c目前还没有被编写，现在我将再次测试linux是否支持直接使用相对路径：

由此可见，linux与先前的问题一样，我们仍然需要获取绝对路径。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> /*提供readlink*/
#include <limits.h> /*提供PATH_MAX*/
char *the_path(){
    char path[PATH_MAX];
    char *dir_path = NULL;
    ssize_t len = readlink("/proc/self/exe",path,sizeof(path) - 1);
    if(len != -1){
        path[len] = '\0';
        printf("绝对路径:%s\n",path);
        dir_path = strdup(path);
        char *last_slash = strrchr(dir_path,'/');
        if(last_slash != NULL){
            *last_slash = '\0';
        }
        printf("目录路径为:%s\n",dir_path);
        return dir_path;
    }
    else{
        perror("readlink");
    }
    return NULL;
}
char *concatenate(const char *str1,const char *str2){
    size_t len1 = strlen(str1);
    size_t len2 = strlen(str2);
    char *result = (char*)malloc(len1 + len2 + 1);
    if(result == NULL){
        return NULL;
    }
    strcpy(result,str1);
    strcat(result,str2);
    return result;
}
int main(){
    char text[20];
    if(freopen(concatenate(the_path(),"/a.txt"),"r",stdin) == NULL){
        perror("无法打开文件\n");
    }
    else{
        if(fgets(text,sizeof(text),stdin) == NULL){
            printf("文件读取失败\n");
            return 1;
        }
        fclose(stdin);
        printf("%s\n",text);
    }
    return 0;
}

运行结果如下：

文件读取成功。

windows获取绝对路径

windows的问题与先前一致，测试就跳过了。

环境：

代码：

#include <stdio.h>
#include <windows.h>
#include <tchar.h> /*提供 _TCHAR 宏和 _tprintf 等函数*/
#include <limits.h>
#include <string.h>
char *the_path() {
    _TCHAR path[MAX_PATH];
    DWORD length = GetModuleFileName(NULL,path,MAX_PATH);
    char *dir_path = NULL;
    if (length > 0) {
        _tprintf(_T("绝对路径(Unicode): %s\n"),path);
        dir_path = strdup(path);
        if(dir_path != NULL){
            char *last_slash = strrchr(dir_path,'\\');
            if(last_slash != NULL){
                *last_slash = '\0';
            }
            printf("目录路径为：%s\n",dir_path);
            return dir_path;
        }
    }
    else {
        DWORD error = GetLastError();
        _ftprintf(stderr,_T("失败代码: %lu\n"),error);
    }
    return NULL;
}
char *concatenate(const char *str1,const char *str2){ /*字符拼接*/
    size_t len1 = strlen(str1);
    size_t len2 = strlen(str2);
    char *result = (char*)malloc(len1 + len2 + 1);
    if(result == NULL){
        return NULL;
    }
    strcpy(result,str1);
    strcat(result,str2);
    return result;
}
int main() {
    char text[20];
    if(freopen(concatenate(the_path(),"/a.txt"),"r",stdin) == NULL){
        perror("无法打开文件");
    }
    else{
        if(fgets(text,sizeof(text),stdin) == NULL){
            printf("文件读取失败\n");
            return 1;
        }
        fclose(stdin);
        printf("%s\n",text);
    }
    return 0;
}

为了使PowerShell正常显示中文，代码与测试文本都以GBD格式存储。

效果如下：

文件读取成功。

跨平台支持

为了让代码可以在不同系统上顺利运行，同时适配一些没有考虑的系统，我将代码中和到了一起，并添加了argv获取方式作为保底。

最后的代码是这样的：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#if defined(_WIN32) || defined(_WIN64)
    #include <windows.h>
    #include <tchar.h>
#elif defined(__linux__)
    #include <unistd.h>
    #include <limits.h>
#elif defined(__APPLE__)
    #include <mach-o/dyld.h>
    #include <libgen.h>
    #include <unistd.h>
#endif

char *concatenate(const char *str1,const char *str2) {
    size_t len1 = strlen(str1);
    size_t len2 = strlen(str2);
    char *result = (char*)malloc(len1 + len2 + 1);
    if(result == NULL){
        return NULL;
    }
    strcpy(result,str1);
    strcat(result,str2);
    return result;
}

/*核心代码开头*/
char *get_path_from_argv(const char *argv0){
    if(argv0 == NULL){
        return NULL;
    }
    char *real_path = NULL;
    #if defined(_WIN32) || defined(_WIN64)
        real_path = _fullpath(NULL, argv0, 0);
    #else
        real_path = realpath(argv0, NULL);
    #endif
    if(real_path != NULL){
        printf("使用argv[0]获取绝对路径：%s\n",real_path);
        char *dir_path = strdup(real_path);
        if(dir_path != NULL){
            char *last_slash = strrchr(dir_path,'/');
            if(last_slash == NULL){
                last_slash = strrchr(dir_path,'\\');
            }
            if(last_slash != NULL){
                *last_slash = '\0';
            }
            printf("目录路径为：%s\n",dir_path);
        }
        free(real_path);
        return dir_path;
    }
    return NULL;
}

char *the_path(int argc,char *argv[]){
    #if defined(_WIN32) || defined(_WIN64)
        _TCHAR path[MAX_PATH];
        DWORD length = GetModuleFileName(NULL,path,MAX_PATH);
        char *dir_path = NULL;
        if(length > 0){
            _tprintf(_T("绝对路径(Unicode): %s\n"), path);
            dir_path = strdup(path);
            if(dir_path != NULL){
                char *last_slash = strrchr(dir_path,'\\');
                if(last_slash != NULL){
                    *last_slash = '\0';
                }
                printf("目录路径为：%s\n",dir_path);
                return dir_path;
            }
        }
        else{
            DWORD error = GetLastError();
            _ftprintf(stderr, _T("失败代码: %lu\n"),error);
        }
        char *argv_path = get_path_from_argv(argc > 0 ? argv[0] : NULL);
        if(argv_path != NULL){
            return argv_path;
        }
        return NULL;
    #elif defined(__linux__)
        char path[PATH_MAX];
        char *dir_path = NULL;
        ssize_t len = readlink("/proc/self/exe",path,sizeof(path) - 1);
        if(len != -1){
            path[len] = '\0';
            printf("绝对路径:%s\n",path);
            dir_path = strdup(path);
            char *last_slash = strrchr(dir_path,'/');
            if(last_slash != NULL){
                *last_slash = '\0';
            }
            printf("目录路径为:%s\n",dir_path);
            return dir_path;
        }
        else{
            perror("readlink");
        }
        char *argv_path = get_path_from_argv(argc > 0 ? argv[0] : NULL);
        if(argv_path != NULL){
            return argv_path;
        }
        return NULL;
    #elif defined(__APPLE__)
        char path[PATH_MAX];
        uint32_t size = sizeof(path);
        char *real_path = NULL;
        char *dir_path = NULL;
        if(_NSGetExecutablePath(path,&size) == 0){
            printf("获取路径为：%s\n",path);
            real_path = realpath(path,NULL);
            if(real_path != NULL){
                printf("绝对路径为：%s\n",real_path);
                dir_path = strdup(real_path);
                if(dir_path != NULL){
                    char *last_slash = strrchr(dir_path,'/');
                    if(last_slash != NULL){
                        *last_slash = '\0';
                    }
                    printf("目录路径为：%s\n",dir_path);
                }
            }
            else{
                perror("realpath");
            }
        }
        else{
            fprintf(stderr,"缓冲太小，需要 %u bytes\n",size);
        }
        if(dir_path != NULL){
            free(real_path);
            return dir_path;
        }
        char *argv_path = get_path_from_argv(argc > 0 ? argv[0] : NULL);
        if(argv_path != NULL){
            return argv_path;
        }
        return NULL;
    #else
        fprintf(stderr, "不支持的操作系统\n");
        char *argv_path = get_path_from_argv(argc > 0 ? argv[0] : NULL);
        if(argv_path != NULL){
            return argv_path;
        }
        return NULL;
    #endif
}
/*核心代码结尾*/
int main(int argc,char *argv[]){ /*如果使用argv，需要加上“int argc,char *argv[]”这一段*/
    #if defined(__APPLE__)
        char cwd[PATH_MAX];
        if(getcwd(cwd,sizeof(cwd)) != NULL){
            printf("当前目录: %s\n", cwd);
        } 
        else{
            perror("getcwd()失败");
        }
    #endif
    char text[20];
    char *full_path = concatenate(the_path(argc,argv),"/a.txt"); /*所拼接的路径不能为“./a.txt”，需要为“/a.txt”的格式*/
    if(freopen(full_path,"r",stdin) == NULL){
        perror("无法打开文件");
    }
    else{
        if(fgets(text,sizeof(text),stdin) == NULL){
            printf("文件读取失败\n");
            free(full_path);
            return 1;
        }
        fclose(stdin);
        printf("%s\n",text);
    }
    free(full_path);
    return 0;
}