How virtual functions affect the way points are generated in OpenGL? - c++

Question

I have a project where I draw a triangle using points, it is called Sierpinski Gasket. To achieve that I am using a class Vx which holds x and y values. The problem is it throws different values if any method is virtual and I wonder why. How virtual functions affect the way the points are generated in the following OpenGL code?
My vector class has the following declaration:
class Vx {
public:
float x;
float y;
Vx();
Vx(const float& value);
Vx(const float& x, const float& y);
Vx(const Vx& v);
float getX() const;
void setX(const float& x);
float getY() const;
void setY(const float& y);
const float operator [] (int i) const;
operator const float* () const;
operator float* ();
float& operator [] (int i);
};
std::ostream& operator<<(std::ostream& os, const Vx v);
Vx operator+(const Vx& p1, const Vx& p2);
Vx operator/(const Vx& p1, const Vx& p2);
And it's implementation is:
Vectors::Vx::Vx() : x(0), y(0)
{
}
Vectors::Vx::Vx(const float& value) : x(value), y(value)
{
}
Vectors::Vx::Vx(const float& x, const float& y) : x(x), y(y)
{
}
Vectors::Vx::Vx(const Vx& v) : x(v.x), y(v.y)
{
}
float Vectors::Vx::getX() const
{
return this->x;
}
void Vectors::Vx::setX(const float& x)
{
this->x = x;
}
float Vectors::Vx::getY() const
{
return this->y;
}
void Vectors::Vx::setY(const float& y)
{
this->y = y;
}
float& Vectors::Vx::operator[](int i)
{
return *(&x + i);
}
const float Vectors::Vx::operator[](int i) const
{
return *(&x + i);
}
Vectors::Vx::operator const float* () const
{
return static_cast<const float*>(&x);
}
Vectors::Vx::operator float* ()
{
return static_cast<float*>(&x);
}
std::ostream& Vectors::operator<<(std::ostream& os, const Vx v)
{
os << "Vx: " << "x = " << v.x << ", y = " << v.y << std::endl;
return os;
}
Vx Vectors::operator+(const Vx& p1, const Vx& p2)
{
return Vx(p1.x + p2.x, p1.y + p2.y);
}
Vx Vectors::operator/(const Vx& p1, const Vx& p2)
{
return Vx(p1.x / p2.x, p1.y / p2.y);
}
My main class starts setting up OpenGL to be ready to draw, and at some point I create a buffer with the data as following:
void sierpinskiGasket() {
using namespace Vectors;
/*
Creamos la informacion para el triangulo
*/
const int numPoints = 5000;
Vx points[numPoints];
points[0] = Vx(0.0f, 0.0f);
Vx vertices[] = {
Vx(-0.50f, -0.50f),
Vx(0.50f, -0.50f),
Vx(0.0f, 0.50f)
};
for (int i = 1; i < numPoints;i++) {
int j = rand() % 3;
points[i] = (points[i - 1] + vertices[j]) / 2;
}
/*
Generamos el buffer para el triangulo
*/
unsigned int triangle_vbo;
glGenBuffers(1, &triangle_vbo);
glBindBuffer(GL_ARRAY_BUFFER, triangle_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
}
The result I get is the next triangle (which is okay):
But if I change any method of my Vx class to virtual, the next thing happens:

Answer 1

Class with virtual methods has implicit field - pointer to VMT (virtual method table). You can check it by printing sizeof(Vx) with and without virtual methods. Internal representation of classes and structs is not specified by the C++ standards and varies between compilers, so you should not pass classes with virtual methods to functions like glBufferData.

Answer 2

After some research, I found a more detailed answer to this question since it explains why virtual functions affect the way class members have different memory allocations throwing different results, in addition with some documentation from the c++ reference that explains about polymorphic objects and memory allocation too.
In fact, it is undefined behaviour and the answer to the following question explains why in a short and better way.
https://stackoverflow.com/a/48300540/13716517
But also I would like to add what the c++ reference says from the next 2 links:
https://en.cppreference.com/w/cpp/language/object
https://en.cppreference.com/w/cpp/language/memory_model
Where we can find the next documentation from:
Polymorphic objects: Objects of a class type that declares or inherits
at least one virtual function are polymorphic objects. Within each
polymorphic object, the implementation stores additional information
(in every existing implementation, it is one pointer unless optimized
out), which is used by virtual function calls and by the RTTI features
(dynamic_cast and typeid) to determine, at run time, the type with
which the object was created, regardless of the expression it is used
in. For non-polymorphic objects, the interpretation of the value is
determined from the expression in which the object is used, and is
decided at compile time.
Memory location: A memory location is an object of scalar type
(arithmetic type, pointer type, enumeration type, or std::nullptr_t)
or the largest contiguous sequence of bit fields of non-zero length
Note: Various features of the language, such as references and virtual
functions, might involve additional memory locations that are not
accessible to programs but are managed by the implementation.
Taking all that in consideration, we can see where the undefined behaviour for using virtual functions comes from in more detail, understanding how they change the behaviour when generating the points.