C++；虽然函数在同一文件中定义，但未定义引用 我目前正在尝试用C++编写OpenGL程序。当我试图编译我的程序时，我得到了未定义的引用，在我调用类的成员函数的任何地方，尽管我从成员函数调用这些函数

以下是我收到的错误消息：

make clean && make
rm -f *.o *~ main
g++   -c main.cpp  -o main.o
g++   -c renderer.cpp  -o renderer.o
g++   -o main main.o renderer.o  -lglut -lGL -lGLEW
renderer.o: In function `Renderer::resize(int, int)':
renderer.cpp:(.text+0x299): undefined reference to `Renderer::Perspective(float*, float, float, float, float)'
renderer.o: In function `Renderer::setupShaders()':
renderer.cpp:(.text+0x43d): undefined reference to `Renderer::loadShaderSrc(char const*, int&)'
renderer.cpp:(.text+0x456): undefined reference to `Renderer::loadShaderSrc(char const*, int&)'
renderer.cpp:(.text+0x4e7): undefined reference to `Renderer::printShaderInfoLog(int)'
renderer.cpp:(.text+0x4fe): undefined reference to `Renderer::printShaderInfoLog(int)'
renderer.cpp:(.text+0x568): undefined reference to `Renderer::printProgramInfoLog(int)'
collect2: Fehler: ld gab 1 als Ende-Status zurück
make: *** [main] Fehler 1

这是我的源文件：

main.cpp：

#include "renderer.h"

static Renderer *renderer;

static void glutDisplay()
{
    renderer->display();
    glutSwapBuffers();
}

static void glutResize(int w, int h)
{
    renderer->resize(w, h);
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(320, 320);
    glutCreateWindow("Title");

    GLenum res = glewInit();
    if(res != GLEW_OK)
        return -1;

    glutDisplayFunc(glutDisplay);
    glutReshapeFunc(glutResize);
    renderer = new Renderer;
    renderer->init();
    glutMainLoop();
    return 0;
}

renderer.cpp：

#include "renderer.h"

Renderer::Renderer() : programID(0.0), vao(0), vbo(0), vertexLoc(0), colorLoc(0), projectionLoc(0), modelviewLoc(0)
{}

Renderer::~Renderer()
{
    glDeleteVertexArrays(1, &vao);
    glDeleteBuffers(1, &vbo);
    glDeleteProgram(programID);
    glDeleteShader(vertShaderID);
    glDeleteShader(fragShaderID);
}

void Renderer::init()
{
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_DEPTH);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    setupShaders();

    //glGenVertexArrays(1, vao);
    glGenBuffers(1, &vbo);

    float triangleVertexData[] = {
       0.0f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
      -0.5f,-0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
       0.5f,-0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f,
    };

    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(triangleVertexData), triangleVertexData, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

void Renderer::resize(int w, int h)
{
    glViewport(0, 0, w, h);
    Perspective(projection, 45.0f, (float)w/(float)h, 0.5f, 4.0f);
}

void Renderer::display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glUseProgram(programID);
    glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, projection);
    glUniformMatrix4fv(modelviewLoc, 1, GL_FALSE, modelview);

    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glEnableVertexAttribArray(vertexLoc);
    glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(float), 0);
    glDisableVertexAttribArray(vertexLoc);
    glEnableVertexAttribArray(colorLoc);
    glVertexAttribPointer(colorLoc, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (void*) (3 * sizeof(float)));
    glDisableVertexAttribArray(colorLoc);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

void Renderer::setupShaders()
{
    vertShaderID = glCreateShader(GL_VERTEX_SHADER);
    fragShaderID = glCreateShader(GL_FRAGMENT_SHADER);

    GLint vertlength, fraglength;
    const char* vertexshader = loadShaderSrc("shaders/simple.vert", vertlength);
    const char* fragmentshader = loadShaderSrc("shaders/simple.frag", fraglength);

    glShaderSource(vertShaderID, 1, &vertexshader, &vertlength);
    glShaderSource(fragShaderID, 1, &fragmentshader, &fraglength);

    free((char*) vertexshader);
    free((char*) fragmentshader);

    glCompileShader(vertShaderID);
    glCompileShader(fragShaderID);

    printShaderInfoLog(vertShaderID);
    printShaderInfoLog(fragShaderID);

    programID = glCreateProgram();
    glAttachShader(programID, vertShaderID);
    glAttachShader(programID, fragShaderID);

    glLinkProgram(programID);
    printProgramInfoLog(programID);

    vertexLoc = glGetAttribLocation(programID, "vertex_position");
    colorLoc = glGetAttribLocation(programID, "vertex_color");

    projectionLoc = glGetUniformLocation(programID, "projection");
    modelviewLoc = glGetUniformLocation(programID, "modelview");
}

void printShaderInfoLog(GLint obj)
{
    int infoLogLength = 0;
    int returnLength  = 0;
    char *infoLog;
    glGetShaderiv(obj, GL_INFO_LOG_LENGTH,&infoLogLength);
    if (infoLogLength > 0) {
      infoLog = (char *)malloc(infoLogLength);
      glGetShaderInfoLog(obj, infoLogLength, &returnLength, infoLog);
      printf("%s\n",infoLog);
      free(infoLog);
    }   
}

void printProgramInfoLog(GLint obj)
{
    int infoLogLength = 0;
    int returnLength  = 0;
    char *infoLog;
    glGetProgramiv(obj, GL_INFO_LOG_LENGTH,&infoLogLength);
    if (infoLogLength > 0) {
      infoLog = (char *)malloc(infoLogLength);
      glGetProgramInfoLog(obj, infoLogLength, &returnLength, infoLog);
      printf("%s\n",infoLog);
      free(infoLog);
    }
}

const char* loadShaderSrc(const char *filename, GLint &filesize)
{
    std::ifstream file(filename, std::ios::in);
    std::string shader( (std::istreambuf_iterator<char>(file) ),
                        (std::istreambuf_iterator<char>()     ) );
    filesize = (GLint) shader.length();
    return shader.c_str();
}

void Perspective(float *a, float fov, float aspect, float zNear, float zFar)
{
    float f = 1.0f / float(tan(fov / 2.0f * (PI / 180.0f)));
    for(int i = 0; i < 16; i++) a[i] = 0.0f;
    a[0] = f / aspect;
    a[1 * 4 + 1] = f;
    a[2 * 4 + 2] = (zNear + zFar) / (zNear - zFar);
    a[3 * 4 + 2] = 2.0f * zNear * zFar / (zNear - zFar);
    a[2 * 4 + 3] = -1.0f;
}

void Modelview(float *mv)
{
    for(int i = 0; i < 16; i++) mv[i] = 0.0f;
    for(int i = 0; i < 4; i++) mv[i * 4 + i] = 1.0f;
    mv[3 * 4 + 2] = -2.0f;
}

#包括“renderer.h”
Renderer:：Renderer（）：programID（0.0）、vao（0）、vbo（0）、vertexLoc（0）、colorLoc（0）、projectionLoc（0）、modelviewLoc（0）
{}
渲染器：：~Renderer（）
{
GLDeleteVertexArray（1和vao）；
glDeleteBuffers（1和vbo）；
glDeleteProgram（programID）；
glDeleteShader（vertShaderID）；
glDeleteShader（fragShaderID）；
}
void呈现器：：init（）
{
glEnable（GLU深度试验）；
峡谷（GL_深度）；
glClearColor（0.0f、0.0f、0.0f、0.0f）；
setupShaders（）；
//Glgenvertexarray（1，vao）；
glGenBuffers（1，&vbo）；
浮点三角形数据[]={
0.0f，0.5f，0.0f，1.0f，0.0f，0.0f，1.0f，
-0.5f，-0.5f，0.0f，0.0f，1.0f，0.0f，1.0f，
0.5f，-0.5f，0.0f，0.0f，0.0f，1.0f，1.0f，
};
glBindBuffer（GL_数组_BUFFER，vbo）；
glBufferData（GL_数组_缓冲区、sizeof（triangleVertexData）、triangleVertexData、GL_静态_绘图）；
glBindBuffer（GL_数组_BUFFER，0）；
}
无效渲染器：：调整大小（int w，int h）
{
glViewport（0,0,w,h）；
透视图（投影，45.0f，（浮动）w/（浮动）h，0.5f，4.0f）；
}
void呈现器：：display（）
{
glClear（GL_颜色_缓冲_位| GL_深度_缓冲_位）；
glUseProgram（programmaid）；
glUniformMatrix4fv（projectionLoc，1，GL_FALSE，projection）；
glUniformMatrix4fv（modelviewLoc，1，GL_FALSE，modelview）；
glBindBuffer（GL_数组_BUFFER，vbo）；
GlenableVertexAttributeArray（vertexLoc）；
glvertexattributepointer（vertexLoc，3，GL_FLOAT，GL_FALSE，7*sizeof（FLOAT），0）；
GLDisableVertexAttributeArray（vertexLoc）；
GlenableVertexAttributeArray（colorLoc）；
glvertexattributepointer（colorLoc，3，GL_FLOAT，GL_FALSE，7*sizeof（FLOAT），（void*）（3*sizeof（FLOAT））；
glDisableVertexAttribArray（colorLoc）；
glBindBuffer（GL_数组_BUFFER，0）；
}
void渲染器：：setupShaders（）
{
vertShaderID=glCreateShader（GL_顶点_着色器）；
fragShaderID=glCreateShader（GL_FRAGMENT_SHADER）；
闪烁顶点长度，fraglength；
const char*vertexshader=loadShaderSrc（“shaders/simple.vert”，vertlength）；
const char*fragmentshader=loadShaderSrc（“shaders/simple.frag”，fraglength）；
glShaderSource（vertShaderID、1、&vertexshader和&vertlength）；
glShaderSource（fragShaderID，1，&fragmentshader，&FragmentGnth）；
自由（（字符*）顶点着色器）；
自由（（字符*）碎片着色器）；
glCompileShader（vertShaderID）；
glCompileShader（fragShaderID）；
printShaderInfoLog（vertShaderID）；
printShaderInfoLog（fragShaderID）；
programID=glCreateProgram（）；
glAttachShader（programmaid，vertShaderID）；
glAttachShader（programmaid，fragShaderID）；
glLinkProgram（programID）；
printProgramInfoLog（程序ID）；
vertexLoc=GLGetAttriblLocation（程序ID，“顶点位置”）；
colorLoc=glGetAttribLocation（程序ID，“顶点颜色”）；
projectionLoc=glGetUniformLocation（programmaid，“projection”）；
modelviewLoc=glGetUniformLocation（程序ID，“modelview”）；
}
void printShaderInfoLog（闪烁对象）
{
int infoLogLength=0；
int returnLength=0；
char*infoLog；
glGetShaderiv（obj、GL信息日志长度和信息日志长度）；
如果（infoLogLength>0）{
infoLog=（char*）malloc（infoLogLength）；
glGetShaderInfoLog（obj、infoLogLength和returnLength、infoLog）；
printf（“%s\n”，信息日志）；
免费（信息日志）；
}   
}
作废打印程序信息日志（闪烁obj）
{
int infoLogLength=0；
int returnLength=0；
char*infoLog；
glGetProgramiv（obj、GL信息日志长度和信息日志长度）；
如果（infoLogLength>0）{
infoLog=（char*）malloc（infoLogLength）；
glGetProgramInfoLog（obj、infoLogLength和returnLength、infoLog）；
printf（“%s\n”，信息日志）；
免费（信息日志）；
}
}
常量字符*loadShaderSrc（常量字符*文件名、闪烁和文件大小）
{
std:：ifstream文件（文件名，std:：ios:：in）；
std:：string着色器（（std:：istreambuf_迭代器（文件）），
（std:：istreambuf_迭代器（））；
filesize=（GLint）shader.length（）；
返回shader.c_str（）；
}
虚空透视图（浮空*a、浮空视野、浮空方位、浮空zNear、浮空zFar）
{
浮子f=1.0f/浮子（tan（视野/2.0f*（PI/180.0f））；
对于（inti=0；i<16；i++）a[i]=0.0f；
a[0]=f/纵横比；
a[1*4+1]=f；
a[2*4+2]=（zNear+zFar）/（zNear-zFar）；
a[3*4+2]=2.0f*zNear*zFar/（zNear-zFar）；
a[2*4+3]=-1.0f；
}
空心模型视图（浮动*mv）
{
对于（inti=0；i<16；i++）mv[i]=0.0f；
对于（inti=0；i<4；i++）mv[i*4+i]=1.0f；
mv[3*4+2]=-2.0f；
}

2.h：

#include <cmath>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string>
#include <GL/glew.h>
#include <GL/glut.h>

#define PI 3.14159

class Renderer {
    private:
        GLuint programID;
        GLuint vertShaderID;
        GLuint fragShaderID;
        GLuint vao;
        GLuint vbo;
        GLint vertexLoc;
        GLint colorLoc;
        GLint projectionLoc;
        GLint modelviewLoc;
        float projection[16];
        float modelview[16];
    public:
        Renderer();
        ~Renderer();
        void init();
        void resize(int w, int h);
        void display();
    private:
        void setupShaders();
        void printShaderInfoLog(GLint obj);
        void printProgramInfoLog(GLint obj);
        const char* loadShaderSrc(const char *filename, GLint &filesize);
        void Perspective(float *a, float fov, float aspect, float zNear, float zFar);
        void Modelview();
};

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义PI 3.14159
类渲染器{
私人：
GLuint程序ID；
灰斑潜蝇；
白蜡虫；
GLuint-vao；
GLuint vbo；
闪烁顶点定位；
闪烁色；
闪烁投影法；
闪烁模式视窗；
浮动投影[16]；
浮动模型视图[16]；
公众：
渲染器（）；
~1（）；
void init（）；
无效调整大小（整数w，整数h）；
void display（）；
私人：
void setupShaders（）；
void printShaderInfoLog（闪烁对象）；
作废打印程序信息日志（GLint obj）；
常量字符*loadShaderSrc（常量字符*文件名、闪烁和文件大小）；
无效透视图（浮动*a、浮动视野、浮动方向、浮动zNear、浮动zFar）；
void Modelview（）；
};

我使用这个Makefile（使用g++和linux）编译：

CC=g++
CFLAGS=-Wall-g
包括=
LFLAGS=
LIBS=-lglut-lGL-lGLEW
SRCS=main.cpp renderer.cpp
OBJS=$（SRCS:.cpp=.o）
主要的
全部：$（主）
$（主要内容）：
CC = g++
CFLAGS = -Wall -g
INCLUDES = 
LFLAGS = 
LIBS = -lglut -lGL -lGLEW
SRCS = main.cpp renderer.cpp
OBJS = $(SRCS:.cpp=.o)
MAIN = main

all:        $(MAIN)

$(MAIN):    $(OBJS)
            $(CC) $(CLFAGS) $(INCLUDES) -o $(MAIN) $(OBJS) $(LFLAGS) $(LIBS)

.cpp.o:     
            $(CC) $(CLFAGS) $(INCLUDES) -c $<  -o $@

clean:      
            $(RM) *.o *~ $(MAIN)