C++ 정의되지 않은 참조가 동일한 파일에 정의되어 있지만

Question

현재 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 :

#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(); 
}; 

나는 (리눅스와 ++ g을 사용하여)이 Makefile을 사용하여 컴파일

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) 

그것은 아마 바보 같은 초보자의 실수하지만 난 그것을 찾을 수 없습니다입니다. 그 함수가 동일한 파일에 정의되어있는 경우 함수에 정의되지 않은 참조를 얻는 방법을 이해하지 못합니다. 나는 당신이 날 도울 수 있기를 바랍니다

는 =)이 Perspective 기능은 Perspective보다는 Renderer::Perspective 당신의 cpp 파일에서

Answer 1

라고합니다. 즉, Perspective이라는 사용하지 않는 함수가 있더라도 Perspective 메서드는 실제로 정의되어 있지 않습니다.

참고 : Renderer 클래스의 다른 private 방법과 동일한 문제가 있습니다.