我正在用 OpenGL 开发一个项目，我让它以最基本的形式运行。现在，我需要这样做，以便我的旋转和轨道“获取”矩阵位于我的 Box.cpp 文件中，我的速度变量是私有(private)的，并且我已经为这些速度变量设置了函数。
我需要访问 main 中的那些变量，但由于它们是私有(private)的，我显然不能。
有人能指出我正确的方向吗？
主要.cpp:
#include "vgl.h"
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <iostream>
#include <vector>
#include "Box.h"
#include "Camera.h"
#include "VertexBufferData.h"
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>
using namespace std;
using namespace glm;
#define SPACEBAR_KEY 32
#define ESCAPE_KEY 033
Camera* camera;
vector<Box * > gameObjects;
bool keyDown[255];
void CheckKeyboard(){
if (keyDown['a'])
camera->RotateLeft();
if (keyDown['d'])
camera->RotateRight();
if (keyDown['w'])
camera->MoveForward();
if (keyDown['s'])
camera->MoveBackWard();
if (keyDown['e'])
camera->StrafeRight();
if (keyDown['q'])
camera->StrafeLeft();
}
void closeApp()
{
delete camera;
for (auto it = gameObjects.begin(); it != gameObjects.end(); ++it) {
delete (*it);
}
}
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case ESCAPE_KEY: // ASCII Escape Key Code
closeApp();
exit(EXIT_SUCCESS);
break;
default:
keyDown[key] = true;
}
glutPostRedisplay();
}
void keyboardUp(unsigned char key, int x, int y)
{
keyDown[key] = false;
}
void mouseWheel(int button, int direction, int x, int y)
{
if (button == 16)
camera->ResetFOV();
else if (direction > 0)
camera->ZoomIn();
else
camera->ZoomOut();
}
void mouseMovement(int x, int y)
{
static bool warp = true;
if (warp)
{
if (x>glutGet(GLUT_WINDOW_WIDTH) / 2)
camera->RotateRight();
else if (x<glutGet(GLUT_WINDOW_WIDTH) / 2)
camera->RotateLeft();
if (y>glutGet(GLUT_WINDOW_HEIGHT) / 2)
camera->RotateUp();
else if (y<glutGet(GLUT_WINDOW_HEIGHT) / 2)
camera->RotateDown();
glutWarpPointer(glutGet(GLUT_WINDOW_WIDTH) / 2, glutGet(GLUT_WINDOW_HEIGHT) / 2);
warp = false;
}
else
warp = true;
}
void timer(int value)
{
glutPostRedisplay();
glutTimerFunc(25, timer, 0);
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
CheckKeyboard();
camera->Update();
for (auto it = gameObjects.begin(); it != gameObjects.end(); ++it) {
(*it)->shaderProgram->bindShader();
glm::mat4 MVP = camera->ProjectionMatrix * camera->ViewMatrix * (*it)->getModelMatrix();
(*it)->shaderProgram->sendUniform4x4("MVP", glm::value_ptr(MVP));
(*it)->Draw();
}
glutSwapBuffers();
}
void init()
{
int i = 0;
camera = new Camera();
memset(keyDown, false, sizeof(keyDown));
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
glutWarpPointer(glutGet(GLUT_WINDOW_WIDTH) / 2, glutGet(GLUT_WINDOW_HEIGHT) / 2);
glutSetCursor(GLUT_CURSOR_FULL_CROSSHAIR);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
VertexBufferData vertexBufferData = VertexBufferData("Data\\Models\\Objects.xml");
gameObjects.push_back(new Box(vertexBufferData, glm::vec3(0.0f, 0.0f, 0.0f), "Data\\Shaders\\Vertex.shader", "Data\\Shaders\\Fragment.shader"));
gameObjects.push_back(new Box(vertexBufferData, glm::vec3(4.0f, 0.0f, 0.0f), "Data\\Shaders\\Vertex.shader", "Data\\Shaders\\Fragment.shader"));
gameObjects[1]->rotationSpeed = 5.0f;
gameObjects[0]->rotationSpeed = 2.5f;
gameObjects[1]->orbitSpeed = 1.0f;
//gameObjects[1]->setRotation(45.0f, vec3(0.0f, 0.0f, 1.0f));
//gameObjects[0]->setScaleMatrix(vec3(2, 2, 2));
//gameObjects[1]->setOrbitMatrix(vec3(2.0f, 0.0f, 0.0f), 45.0f, 1, 365, 0);
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH);
glutInitWindowSize(1024, 768);
glutInitContextProfile(GLUT_CORE_PROFILE);
glutCreateWindow("Satterwhite_Project_3");
if (glewInit())
{
cerr << "Unable to init glew" << endl;
exit(EXIT_FAILURE);
}
init();
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutKeyboardUpFunc(keyboardUp);
glutPassiveMotionFunc(mouseMovement);
glutMouseWheelFunc(mouseWheel);
glutTimerFunc(25, timer, 0);
glutMainLoop();
return 0;
}
盒子.cpp:
#include "Box.h"
Box::Box(VertexBufferData &vbd, vec3 initialPosition,const string vertexShader, const string fragmentShader):GameObject(vertexShader, fragmentShader)
{
degreesRotated = 0.0f;
rotationSpeed = 0.0f;
orbitSpeed = 0.0f;
Position=initialPosition;
vertexBufferData =vbd;
RotationMatrix=mat4(1.0f);
OrbitMatrix = mat4(1.0f);
ScaleMatrix=mat4(1.0f);
TranslationMatrix =translate(glm::mat4(1.0f), Position);
if (!shaderProgram->initialize())
{
std::cerr << "Could not initialize the shaders" << std::endl;
}
shaderProgram->bindShader();
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, vertexBufferData.verticiesSize, &vertexBufferData.verticies[0], GL_STATIC_DRAW);
glGenBuffers(1, &fragmentBuffer);
glBindBuffer(GL_ARRAY_BUFFER, fragmentBuffer);
glBufferData(GL_ARRAY_BUFFER, vertexBufferData.colorSize, &vertexBufferData.colors[0], GL_STATIC_DRAW);
shaderProgram->linkProgram();
}
void Box::setRotation(float degrees, vec3 axis)
{
RotationMatrix = rotate(RotationMatrix, degrees, axis);
}
void Box::setScaleMatrix(vec3 scale)
{
ScaleMatrix = glm::scale(mat4(1.0f), scale);
}
void Box::setOrbitMatrix(float degrees, vec3 axis)
{
OrbitMatrix = rotate(OrbitMatrix, degrees, axis);
}
void Box::Draw()
{
shaderProgram->bindShader();
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glVertexAttribPointer(0, 3, GL_FLOAT,GL_FALSE, 0, BUFFER_OFFSET(0));
glBindBuffer(GL_ARRAY_BUFFER, fragmentBuffer);
glVertexAttribPointer(1, 3, GL_FLOAT,GL_FALSE, 0, BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLES, 0, vertexBufferData.verticies.size());
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
}
盒子.h:
#pragma once
#include "GameObject.h"
class Box : public GameObject
{
private:
mat4 ModelMatrix;
mat4 RotationMatrix;
mat4 OrbitMatrix;
mat4 TranslationMatrix;
mat4 ScaleMatrix;
public:
float rotationSpeed, orbitSpeed, degreesRotated;
void Draw();
virtual ObjectType getType() const { return BOX; }
mat4 getModelMatrix() {return getOrbitMatrix()*TranslationMatrix*getRotationMatrix()*ScaleMatrix;}
mat4 getRotationMatrix()
{
setRotation(rotationSpeed, vec3(0.0f, 0.0f, 1.0f));
return RotationMatrix;
}
mat4 getTranslationMatrix() {return TranslationMatrix;}
mat4 getOrbitMatrix()
{
setOrbitMatrix(orbitSpeed, vec3(0.0f, 0.0f, 1.0f));
return OrbitMatrix;
}
mat4 getScaleMatrix() {return ScaleMatrix;}
void setRotation(float degrees, vec3 axis);
void setScaleMatrix(vec3 scale);
void setOrbitMatrix(float degrees, vec3 axis);
Box(VertexBufferData &vertexBufferData, vec3 initialPosition, const string vertexShader, const string fragmentShader);
vec3 Position;
};
最佳答案
如果您想访问另一个类的私有(private)成员和 protected 成员，请将您想要访问目标类的私有(private)成员和 protected 成员的类声明为“友元类”。
如果您想从 main 或任何其他函数而不是从类中访问私有(private)和 protected 成员，请将该函数声明为类的友元，例如 ostream 插入运算符“<<”和 istream 提取运算符“>>"当您在类中重载它们以打印和输入您的成员(member)数据时。
声明一个类或一个函数成为你类的 friend 就像在现实生活中结交一个你信任的新 friend ，所以你让他/她访问你的 secret 和私有(private)东西，这样他/她就可以帮助你实现你所发现的做自己很难，但友元既不是交换性的也不是关联性的:“成为他/她的 friend 并不意味着你成为他/她的 friend ，因为他/她仍然可能不信任你，因此不会宣布你是他的/她的 friend ”，你父亲的 friend 不是你的 friend 。
使用友元的开销正在破坏数据隐藏和封装原则。所以经验法则是谨慎使用。
如果您希望每个人都可以访问您的私有(private)/ protected 成员，请使用其成员默认为公共(public)范围的结构。或者在你的类公共(public)范围内声明你的成员数据，这是一个非常糟糕的设计。
在此示例中，我将向您展示如何从另一个类和另一个函数(在本例中为 main 函数)访问私有(private)数据:
#include <iostream>
#include <string>
using namespace std;
class Foo; // forward declaration
class Bar; // forward declaration
class Foo
{
public:
Foo() : MyData(100){}
private:
int MyData;
friend class Bar; // any access scope is ok. Bar will have full access to Foo
friend int main(); // main now can access private members
};
class Bar // friend of Foo but Foo is not my Friend so it can't access mine
{
Foo fooObj;
public:
Bar(){}
void PrintFoo()const;
};
void Bar::PrintFoo()const
{
cout << fooObj.MyData << endl; // accessing private member data of class Foo from Bar
}
int main()
{
Foo theFoo;
Bar theBar;
theBar.PrintFoo();
cout << theFoo.MyData << endl; // correct! accessing private members of foo from main because main is friend of Foo.
return 0;
}
关于c++ - 如何从另一个类访问私有(private)变量？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40251872/