trjhtr

Edit: A follow up post can be found here.

So I've started a c++ project, coming from Java / C# there are many obvious differences.

Below is an example of a class I've been working on:

.h

#pragma once

#include <vector>

#include <GL/glew.h>
#include <glm/glm.hpp>

class GLDebug 
private:

 struct Line 
 glm::vec3 p0, p1;
 ;

private:

 std::vector<Line> m_lines;

public:

 GLDebug();
 ~GLDebug();

public:
 void drawLine(const glm::vec3& p0, const glm::vec3& p1);

 void onRender(const glm::mat4& projMatrix, const glm::mat4& viewMatrix);
;

.cpp

#include "GLDebug.h"

#include <glm/gtc/type_ptr.hpp>

GLDebug::GLDebug() 

GLDebug::~GLDebug() 

void GLDebug::drawLine(const glm::vec3& p0, const glm::vec3& p1) 
 m_lines.push_back( p0, p1 );


void GLDebug::onRender(const glm::mat4& projMatrix, const glm::mat4& viewMatrix) 
 glMatrixMode(GL_PROJECTION);
 glLoadMatrixf(glm::value_ptr(projMatrix));

 glMatrixMode(GL_MODELVIEW);
 glLoadMatrixf(glm::value_ptr(viewMatrix));

 glBegin(GL_LINES);

 for (auto& line : m_lines) 
 glVertex3fv(glm::value_ptr(line.p0));
 glVertex3fv(glm::value_ptr(line.p1));
 

 glEnd();

 m_lines.clear();

I've written this basic OpenGL debug utility class based on one I wrote in Java previously. Now it seems fine from what I can tell, but with my limited C++ knowledge I'm wondering if anything I'm doing is redundant / unnecessary and/or performance impacting.

One other thing, I know I can use compiler directives such as
#ifdef _DEBUG etc. If I wanted this class to only exist if compiling in debug mode, Obviously I can't wrap the whole class in the ifdef as that would break other code that is calling functions in the GLDebug class. So I was thinking of wrapping the functions internals instead. Is that a bad approach, I could use them everywhere else as well but that seems kinda bloated and less manageable.

Just a couple points (also well done properly qualifying namespaces, a rare thing to see).

• #pragma once is non-standard. Meaning it will probably work but is not guaranteed to. Bjarne himself recommends against using it.




• Not following your multiple private and public approach. Usually you have a section for each without repeating the keywords.




• It makes more sense to order your interface from public to private as people using it don't want to look at the internals of your class, they want to know what methods they can use.




• You don't do anything in either your constructor or your destructor. In this case it makes sense to let the compiler take care of them.




• Avoid declaring more than one variable per line