C++ 无法识别我在 object.cpp 中的更改

Question

我使用 Visual Studio 2019 社区版。我正在尝试制作一个基本的 OpenGL，以透视方式提取 3d 对象。任何。问题是当我更改任何内容并运行时，程序不会显示该更改，除非我“重建解决方案”.example。

object.cpp

std::cout<< "PosX"<<std::endl;

到

std::cout<< "PosX1"<<std::endl;

当我再次运行时，我得到的是旧输出“PosX”，而不是新输出。

我的项目中有这些文件

main.cpp
header.h
Object.cpp
Puller.cpp
Cube.cpp
Cyclinder.cpp

我在 header.h 中包含了所有其他类文件，并带有安全保障(#ifndef #define class example #endif) 如果你愿意，我可以提供代码。谢谢你的时间。

我没有其他类的头文件。只有 .cpp 文件

对象.cpp

#include "Header.h"

#ifndef OBJECT_CPP
#define OBJECT_CPP

class Object
{
public:
    GLfloat matrixMV[16];
    vec3 Cordinates;
    vec3 Scale;
    vec4r Rotate;

    Object()
    {
    };

    Object(vec3 _Cordinates, vec3 _Scale = vec3(1, 1, 1), vec4r _Rotate = vec4r(0, 0, 0, 0)) : Cordinates(_Cordinates),
                                                                                               Scale(_Scale),
                                                                                               Rotate(_Rotate)
    {
    };

    virtual void move(vec2 direction)
    {
        Cordinates.x += direction.x;
        Cordinates.y += direction.y;
    };
};
#endif

header.h

#pragma once

#include <iostream>
#include "GL/glut.h"

struct vec3
{
    GLfloat x;
    GLfloat y;
    GLfloat z;

    vec3(GLfloat _x = 0, GLfloat _y = 0, GLfloat _z = 0)
    {
        x = _x;
        y = _y;
        z = _z;
    }
};

struct vec2
{
    GLfloat x;
    GLfloat y;

    vec2(GLfloat _x = 0, GLfloat _y = 0)
    {
        x = _x;
        y = _y;
    }
};

struct vec4r
{
    GLfloat x;
    GLfloat y;
    GLfloat z;
    GLfloat radiant;

    vec4r(GLfloat _x = 0, GLfloat _y = 0, GLfloat _z = 0, GLfloat _radiant = 0) : x(_x), y(_y), z(_z), radiant(_radiant)
    {
    };
};

const double PI = 3.1415927;

#include "Object.cpp"
#include "Puller.cpp"
#include "Cube.cpp"
#include "Cyclinder.cpp"
#include "TrianglePrism.cpp"

main.cpp

#include "Header.h"
#include <cstdint>


char wTitle[] = "3D PinPon";

GLfloat aspect = 0;
GLsizei _height;
GLsizei _width;
unsigned int id;
/* PREDEFINATION */
void display();

GLdouble _angle = 0.0;
vec3 rotate = vec3();


Cube block;
Cyclinder RightCylinder;
Cyclinder LeftCylinder;
Cube littlecube;
TrianglePrism my_prism;
Puller my_puller;


void initGL()
{
    glClearColor(0.0, 0.0, 0.0, 1.0); // Set background color to black and opaque
    glClearDepth(1.0); // Set background depth to farthest
    glEnable(GL_DEPTH_TEST); // Enable depth testing for z-culling
    glDepthFunc(GL_LEQUAL); // Set the type of depth-test
    glShadeModel(GL_SMOOTH); // Enable smooth shading
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Nice perspective corrections
}

void reshape(GLsizei width, GLsizei height)
{
    // GLsizei for non-negative integer
    _height = height;
    _width = width; // Compute aspect ratio of the new window
    if (height == 0) height = 1; // To prevent divide by 0
    aspect = (GLfloat)width / (GLfloat)height;

    // Set the viewport to cover the new window
    glViewport(0, 0, width, height);

    // Set the aspect ratio of the clipping volume to match the viewport
    glMatrixMode(GL_PROJECTION); // To operate on the Projection matrix
    glLoadIdentity(); // Reset
    // Enable perspective projection with fovy, aspect, zNear and zFar
    gluPerspective(45.0, aspect, 0.1, 100.0);
    //glOrtho(0.0f, width, height, 0.0f, 0.1f, 100.0f);
}

void processNormalKeys(unsigned char key, int x, int y)
{
    if (key == 27)
        exit(0);
}

void processSpecialKeys(int key, int xx, int yy)
{
    float fraction = 0.1;
    float speed = 0.05f;
    switch (key)
    {
    case GLUT_KEY_LEFT:
        rotate = vec3(rotate.x > 0 ? rotate.x - 0.1f : 0, rotate.y < 1 ? rotate.y + 0.1f : 1,
                      rotate.z > 0 ? rotate.z - 0.1f : 0);
        _angle -= 10;
        block.move(vec2(-1 * speed, 0));
        break;
    case GLUT_KEY_RIGHT:
        rotate = vec3(rotate.x > 0 ? rotate.x - 0.1f : 0, rotate.y < 1 ? rotate.y + 0.1f : 1,
                      rotate.z > 0 ? rotate.z - 0.1f : 0);
        _angle += 10;
        block.move(vec2(1 * speed, 0));
        break;
    case GLUT_KEY_UP:
        rotate = vec3(rotate.x < 1 ? rotate.x + 0.1f : 1, rotate.y > 0 ? rotate.y - 0.1f : 0, 0);
        _angle -= 10;
        break;
    case GLUT_KEY_DOWN:
        rotate = vec3(rotate.x < 1 ? rotate.x + 0.1f : 1, rotate.y > 0 ? rotate.y - 0.1f : 0, 0);
        _angle += 10;

        break;
    }
}

void demo_menu(int id)
{
    switch (id)
    {
    case 1:
        exit(0);
        break;
    case 2:
        glutIdleFunc(display);
        break;
    case 3:
        glutIdleFunc(nullptr);
        break;
    }
    glutPostRedisplay();
}

void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear color and depth buffers
    glMatrixMode(GL_MODELVIEW); // To operate on model-view matrix



    littlecube.render();
    RightCylinder.render();
    LeftCylinder.render();
    my_prism.render();
    my_puller.render();
    block.render();
    //std::cout << LeftCylinder.matrixMV[12] << std::endl;


    glutSwapBuffers(); // Swap the front and back frame buffers (double buffering)
}

void InitObjects()
{
    my_puller = Puller(vec3(-1.95, -2.9, -7.0),vec3(1,1,1),vec4r());
    block = Cube(0.2, vec3(-0.03, -2.35, 0), vec3(3, 1, 1),my_puller);
    littlecube = Cube(0.3, vec3(0, 1, 0));
    RightCylinder = Cyclinder(0.2, 0.5f, 255, 160, 100, vec3(0.8, 0, -6), false);
    LeftCylinder = Cyclinder(0.3, 0.3f, 255, 160, 100, vec3(-0.8, 0, -6), true);
    my_prism = TrianglePrism(vec3(0, 0, -7), vec3(0.3, 0.3, 0.3), vec4r(0.2, 0, 0, 20));

}

void secondDisplay()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear color and depth buffers
    glMatrixMode(GL_MODELVIEW); // To operate on model-view matrix
    glutSwapBuffers(); // Swap the front and back frame buffers (double buffering)
}

int main(int argc, char* argv[])
{
    InitObjects();
    glutInit(&argc, argv); // Initialize GLUT
    glutInitDisplayMode(GLUT_DOUBLE); // Enable double buffered mode
    glutInitWindowSize(480, 720); // Set the window's initial width & height
    glutInitWindowPosition(50, 50); // Position the window's initial top-left corner

    //id = glutCreateWindow("second window");
    //glutSetWindow(id);
    //glutCreateMenu(demo_menu);
    //glutAddMenuEntry("quit", 1);
    //glutAddMenuEntry("start rotation", 2);
    //glutAddMenuEntry("stop rotation", 3);
    //glutAttachMenu(GLUT_RIGHT_BUTTON);
    //glutDisplayFunc(secondDisplay);
    //glutIdleFunc(secondDisplay);


    glutCreateWindow(wTitle); // Create window with the given title
    glutDisplayFunc(display); // Register callback handler for window re-paint event
    glutReshapeFunc(reshape); // Register callback handler for window re-size event
    glutIdleFunc(display);
    glutKeyboardFunc(processNormalKeys);
    glutSpecialFunc(processSpecialKeys);
    initGL(); // Our own OpenGL initialization
    glutMainLoop(); // Enter the infinite event-processing loop
    return 0;
}

Answer 1

问题是当我更改任何内容并运行时，程序不会显示更改，除非我“重建解决方案”

当我第一次写这个答案时，earlier version of this post 中的代码表明，在重建之前，链接器无法使用您所做的更改来使用目标文件——但由于包含的文件从未链接过正确，您永远不会看到更改。

您的问题在于基本的项目组织。

对于初学者，请查看头文件的底部以及如何组织包含。从头文件中删除此部分：

#include "Object.cpp"
#include "Puller.cpp"
#include "Cube.cpp"
#include "Cyclinder.cpp"
#include "TrianglePrism.cpp"

虽然包含来自其他 *.cpp 文件的 *.cpp 文件是合法的 C++，但它并没有真正遵守 One Definition Rule。

源文件 (*.cpp) 应该包含头文件，而不是相反。

头文件应该包含类声明之类的东西，源文件包含它们各自的实现。

如果你想要一个头文件，那很好。它应该是这样的：

header.h

#ifndef MYPROJECT_HEADER_H
#define MYPROJECT_HEADER_H

// all your header specifications

#endif

那么，您所有的*.cpp 文件都包含header.h。

我不明白您以这种方式组织项目的目的是什么。如果您要采用传统的、面向对象的方法进行开发，您将在头文件中创建类声明，然后将这些头文件包含在您想要操作所述类的某些实例的任何 *.cpp 文件中。

您的main.cpp 文件应该是将所有内容粘合在一起的粘合剂。您的其他 *.cpp 文件应该是您在其他 *.h 文件中定义的类的实现。