Cpps on BadproG

C++ - NVIDIA CUDA - Using the compute_xy and sm_xy compile options to generate an executable

Wed, 22 Jun 2022 00:00:00 +0000

To use an NVIDIA GPU (the graphic card processor) you need a CUDA driver.

And if you want to compile a program for a GPU you’ll have to use the CUDA toolkit.

In this tutorial we’re going to see how to compile your project in order to generate an executable able to function on all available NVIDIA GPU (past, present and future).

By saying “all” we say not deprecated yet of course.

C++ - Qt Framework - Mixing native OpenGL functions with Qt ones

Fri, 20 May 2022 00:00:00 +0000

Having the Qt Framework as GUI for OpenGL can be helpful of course but sometimes it seems easier to use the native OpenGL functions directly.

This is exactly what we are going to see in this tutorial by mixing Qt and native OpenGL functions.

First to all

For this tutorial recipe we are going to use:

2 different pairs of shaders (vertex and fragment)
2 VAOs
2 VBOs
2 EBOs

Shaders will be placed in the “shader/” directory and other files directly at the root.

C++ - Qt Framework - Using QOpenGLWidget to display a shape with lighting and normal vectors

Thu, 28 Oct 2021 00:00:00 +0000

Lighting is certainly one of the most interesting effect that we can make with OpenGL.

Combined with colors and normal vectors, lighting becomes visually realistic.

In this tutorial we are going to see how to draw a main shape (kind of a rectangular cube), another one inside the first one and a third representing our lighting source.

We are also going to add normal vectors to these two shapes but with opposite directions.

C++ - OpenCV - Hello world

Tue, 12 Oct 2021 00:00:00 +0000

In a previous tutorial we set up OpenCV with Visual Studio.

This time we are going to make our first Hello world OpenCV project.

Let’s see that.

First of all

In this tutorial we’ll change the color model of our image.

Choose an image with colors because we are going to change them into a grayscale model.

We’ll be able to come back to the original image colors.

To achieve this 2 keys will be used:

C++ - OpenCV - Setting up with Visual Studio

Sun, 10 Oct 2021 00:00:00 +0000

OpenCV is an interesting library aimed to computer vision.

But before playing with it, it’s necessary to set up your IDE.

This IDE will be Visual Studio for this tutorial.

So let’s get started.

First of all

Let’s start by downloading the OpenCV library from the official GitHub.

For this tutorial we’ll use the 4.5.3 version:

https://github.com/opencv/opencv/releases/tag/4.5.3

For the latest version, it should be there:

https://github.com/opencv/opencv/releases

Take the following file for our tutorial:

C++ - Qt Framework - Using QOpenGLWidget to display a window for moving shapes with keyboard and mouse

Tue, 06 Apr 2021 00:00:00 +0000

In the past tutorials about Qt and OpenGL we saw how to deal with some basic tasks.

Let’s see this time something a bit more advanced with the QOpenGLWidget class in order to display a scene from a window with a shape.

This shape (a cube) can be rotated, translated, zoomed with the keyboard and the mouse.

I added some options to change this cube into a colored or texured shape directly from the GUI.

C++ - Qt Framework - Using OpenGL texture with index array

Thu, 21 Jan 2021 00:00:00 +0000

Playing with colors can be fun but what about textures?

What about something really realistic?

In this OpenGL tutorial for Qt we are going to apply a texture on our dear triangles.

Yes in OpenGL there are only triangles, no other kinds of shapes available but with some variations though (the famous primitives).

First of all

We are going to see how to create a struct named StructVertex to handle a vertex and its texture in one object.

C++ - Qt Framework - Using 1 OpenGL VAO and 2 VBOs with only 1 array for both position and color of each vertex

Wed, 13 Jan 2021 00:00:00 +0000

As we saw, in the last tutorial about using a VAO and VBO to handle 2 different objects on the scene with OpenGL, it’s possible to have 2 arrays of vertex: one to manage the position and one to deal with the color.

This time we are going to see how to handle it with only one array.

So let’s get started.

First of all

It’s an easy example with only 3 points on the screen and each one with one different color: red, green and blue (the famous RGB).

C++ - Qt Framework - Using OpenGL VAO and VBO to handle 2 different objects on the scene

Fri, 01 Jan 2021 00:00:00 +0000

VAO (Vertex Array Object) and VBO (Vertex Buffer Object) were introduced to help programmers since OpenGL 3.0.

So it’s not a recent features but if you just started learning OpenGL it could be very complex to understand.

Furthermore if you are learning OpenGL and want to use it with Qt together, it becomes a real nightmare.

So what are these vertex objects and how to use them to manage two different objects on the scene?

C++ - Boost - Converting std::vector to Boost.Python Numpy ndarray

Mon, 25 Nov 2019 00:00:00 +0000

You have a C++ std::vector and you want to convert it to a Boost.Python Numpy ndarray.

But, once the ndarray got, you want to get back to the C++ array.

How to do that?

Let’s see that in this Boost.Python tutorial.

First of all

We need to install Python 3 and Boost on your computer.

So in order to have the exact same software and libraries installed in the exact same locations, I suggest to follow the 2 following tutorials:

C++ - Boost - Using Boost.Python Numpy from_data()

Sun, 24 Nov 2019 00:00:00 +0000

If you are using Python then NumPy is quite interesting for manipulating arrays.

But how do we do that with C++ and Boost.Python NumPy extension?

That’s what we are going to see in this Windows tutorial with an easy example of the from_data() method.

First of all

We need to install Python 3 and Boost on your computer.

So in order to have the exact same software and libraries installed in the exact same locations, I suggest to follow the 2 following tutorials:

C++ - Boost - Building the Boost.Python NumPy extension as a library

Tue, 19 Nov 2019 00:00:00 +0000

If you are a scientist and interested in Python, you certainly already know the NumPy package.

In this tutorial I’ll propose to explain how to install it on Windows in order to be used with the Boost.Python library.

We’ll also make an Hello world example.

First of all

We need to install Python 3 and Boost on your computer.

So in order to have the exact same software and libraries installed in the exact same locations, I suggest to follow the 2 following tutorials:

C++ - Boost - Using Boost.Python library on Windows to create a DLL

Wed, 13 Nov 2019 00:00:00 +0000

Communication between 2 different language isn’t so easy.

It’s often possible to find libraries to help us achieve this behaviour.

That’s what we are going to see in this Boost.Python tutorial for Windows.

Let’s get started.

First of all

We need to install Python 3 and Boost on your computer.

So in order to have the exact same software and libraries installed in the exact same locations, I suggest to follow the 2 following tutorials:

C++ - Boost - Setting up on Windows 10

Sun, 10 Nov 2019 00:00:00 +0000

Boost libraries are some of the famous ones in the C++ world.

They contain tons of functionalities but aren’t so easy to use or even understand.

First things first, let’s try to install it in on our dear Windows 10 operating system (it should work as well on Windows 11).

And test it with Visual Studio 2017 and Visual Studio 2019.

Ready? Let’s do it in this Boost installation tutorial for Windows 10.

C++ - Qt Framework - Using QStyledItemDelegate for displaying a QCheckBox in a QTableView

Fri, 15 Mar 2019 00:00:00 +0000

Adding text and numbers in an QAbstractItemModel was the easy part of the Qt Model/View design.

In this tutorial we are going a bit further by adding a QCheckBox directly on each item of a column.

But instead of using the createEditor() method we’re going to use only the paint() one.

Let’s painting.

First of all

For this example adding a visual QObject is generally made with the createEditor() method.

C++ - Windows - Creating a dynamic-link library (DLL)

Thu, 14 Mar 2019 00:00:00 +0000

Creating a .DLL is an interesting process that allows a better comprehension how a dynamic-link library works on Windows.

No need to say that we’ll use Visual Studio for that.

Ready to dynamic linking?

Let’s link.

First of all

We need of course Visual Studio 2017 but feel free to use the version of your choice.

We’are going to create a dynamic-link library, at first, then create an application that’ll use this library.

C++ - Qt Framework - Using QAbstractItemModel with QTableView and QListView

Mon, 11 Mar 2019 00:00:00 +0000

The QAbstractItemModel is usually used with views like QTableView, QTreeView or QListView.

We’re going to see how to use this class in a very easy example.

To be honest nothing is easy but we’ll use the minimum elements in order to have something useful for every new project.

Let’s see that in this QAbstractItemModel tutorial.

First of all

The Model/View design is quite different from the classic Widgets.

Indeed, here the view and the model are separated in at least two different classes.

C++ - Qt Framework - Using QDataStream

Mon, 04 Feb 2019 00:00:00 +0000

The QDataStream class allows to stock data from an input and give back this data to an output.

Quite interesting when you want, for example, to transfer data from a computer to another.

Let’s see that in this QDataStream tutorial.

First of all

In this tutorial we’re going to create a custom object (BadprogDS) and transfer it to another one.

It’ll involve overload stream operators such as “«” and “»”.

C++ - Visual Studio IDE - Sharing project property sheets on many projects

Wed, 09 Jan 2019 00:00:00 +0000

What is really annoying is to do again and again the same task without having something new to do.

Set a Visual Studio project is one of this thing that you would like to automatize.

The property manager allows us to do this kind of mechanism.

We, indeed, are going to see how to share configurations from many C++ projects.

Let’s get started.

First of all

Visual Studio IDE: https://visualstudio.microsoft.com/

Let’s create a solution and 3 projects:

C++ - Design pattern - Command

Tue, 14 Aug 2018 00:00:00 +0000

The Command design pattern creates a list of objects on which we’re going to apply a generic method.

It’s a bit unusal because an object will request a method as parameter.

This makes the Command design pattern a versatile one but maybe not so easy to handle at first.

Once again an interesting study case.

Let’s see that in this Command design pattern tutorial.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-command

There are many ways to use this Command design pattern.

C++ - Design pattern - Memento

Wed, 06 Jun 2018 00:00:00 +0000

The Memento design pattern allows an object to retrieve last states of another object.

This is used for example in the undo mechanism.

So it’s a very interesting pattern that doesn’t use any interface.

But instead it uses an opaque pointer in order to store old states of the main object.

Let’s see that in this Memento design pattern tutorial.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-memento

This pattern may seem obscur at first glance and maybe you have some questions such as: Why do we have to use three classes to save states of an object?

C++ - Design pattern - Strategy

Sun, 13 May 2018 00:00:00 +0000

The Strategy design pattern allows to change behaviour of a program depending on a context.

It means that a single class can manage many others without knowing that those classes even exist.

Interesting isn’t it?

Let’s see that in this Strategy design pattern tutorial.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-strategy

In this example we are going to use a Context as a manager, an IStrategy as interface, Strategy1 and Strategy2 as dashboards.

C++ - Design pattern - Proxy

Thu, 10 May 2018 00:00:00 +0000

The Proxy design pattern is in charge of managing another class.

It’s like a firewall that you cannot overstep.

There are several reasons to use a Proxy instead of directly another class.

For example it can check if a client accessing an object has permission to do that or it can substitute to this object until someone really needs it (in order to avoid useless memory loading).

So it’s a more complex object than the real one.

C++ - Design pattern - Mediator

Tue, 08 May 2018 00:00:00 +0000

The Mediator design pattern allows to unlink objects from each other.

It’s like a manager that centralizes every action performed by a component in order to dispatch these events to all other objects that need to know information.

It could be seen as a design pattern quite accessible in term of complexity.

Let’s try it in an example.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-mediator

What’s interesting in this design pattern is that each Ship doesn’t know who are other Ships.

C++ - Standard library - move

Sun, 29 Apr 2018 00:00:00 +0000

The move template function allows to change an object owner.

We’re not going to dive in the heart of the move semantics.

Instead we’re going to see a really easy example of how it works.

Let’s get started.

First of all

In this move tutorial we’re going to create 3 Ships, check their memory address then pass them to a Manager in order to add them to the Manager list.

C++ - Design pattern - Decorator

Wed, 11 Apr 2018 00:00:00 +0000

The Decorator design pattern allows an object to be decorated in different ways not by inheriting from another class but by adding features directly to this object.

It’s main interest is to avoid multiplication of classes that would be almost the same as the main one.

This design pattern has an interesting architecture even if not so easy to understand at first.

Let’s see how this Decorator design pattern works.

C++ - Design pattern - Prototype

Thu, 05 Apr 2018 00:00:00 +0000

The Prototype design pattern is used in order to clone an object.

Main goal to prototype design pattern is to create new objects with default values.

This cloning operation is actually a copy of an object and can be made with a shallow or a deep copy.

Let’s see that in this Prototype design pattern tutorial.

First of all

Find the complete code on GitHub:

https://github.com/badprog/badprog-design-pattern-prototype

There are two different ways to copy an object: shallow and deep.

C++ - Design pattern - Factory method

Sun, 04 Mar 2018 00:00:00 +0000

The Factory method design pattern is a really helpful one and a great dive into the world of design patterns.

In our example we are going to use an interface and some concrete classes.

If by reading this you are still interested in the concept, let’s see the Factory method design pattern in this tutorial.

First of all

GitHub: https://github.com/badprog/badprog-design-pattern-singleton-factory-method

In the following tutorial we are going to use an interface class called IShip that three other classes will inherit: ShipTiny, ShipNormal and ShipEnormous.

C++ - Design pattern - Singleton

Wed, 14 Feb 2018 00:00:00 +0000

This Singleton design pattern is certainly the most known and maybe the most easiest to understand.

Its goal is to guarantee that an object will be created only once through all the program.

So this object has to be unique, can’t even be created twice nor copied and it must be accessible through the entire application.

This is for example the case when you have a logging class that must be accessible by almost every class in your program.

C++ - Design pattern - Observer

Wed, 31 Jan 2018 00:00:00 +0000

The Observer design pattern allows an object (often called Subject) to inform other objects (Observers) that an event has occurred.

It’s particularly useful when you have data from a Subject but you don’t know how this data will be used by the Observers.

For example, data from a Subject can be used to display a text in an Observer and a chart in another Observer (even if data is the same).

C++ - CMake - Setup with Cygwin

Fri, 18 Aug 2017 00:00:00 +0000

There are many ways to create a Makefile.

In this tutorial we are going to see how to generate a Makefile with CMake on Windows.

Indeed, CMake is a complex but interesting tool that can generate native Makefiles for the compiler of your choice.

But it’s not all, CMake can also create some useful project files, for a lot of IDE (such as Visual Studio or Eclipse for example) and almost every OS (like GNU/Linux, Windows, Mac, etc.).

C++ - Google Test - Set up projects to use the gtest library

Thu, 10 Aug 2017 00:00:00 +0000

Creating a library for your Google Test framework is a good practise.

It separates your main project, your library and your tests code.

A great way to deal with your dev team and your test team.

Visual Studio will be our IDE for this tutorial.

So let’s get started.

First of all

For this tutorial we need:

Visual Studio 2017 Community: https://www.visualstudio.com/downloads/
Google Test 1.8.0: https://github.com/google/googletest/releases

Google Test will be installed in this directory:

C++ - Google Test - Generating the gtest.lib from gtest.sln with Visual Studio

Mon, 07 Aug 2017 00:00:00 +0000

Google Test framework is provided with a solution already generated that we can use with Visual Studio.

It’s the gtest.sln file.

But to use it we have to accomplish some steps in order to having it working properly.

This is what we will see in this Google Test tutorial.

Let’s get started.

First of all

For this tutorial we need:

Visual Studio 2017 Community: https://www.visualstudio.com/downloads/
Google Test 1.8.0: https://github.com/google/googletest/releases

Google Test will be installed in this directory:

C++ - Google Test - Using a Makefile to generate tests

Sun, 06 Aug 2017 00:00:00 +0000

After succeeded in accomplishing the Google Test setup by hand we are going to see how to use a Makefile to create our running tests.

Of course, this time, we will use the Cygwin CLI in order to create our tests example.

So don’t wait anymore, let’s get started.

First of all

For this Google Test tutorial, we need some useful tools to create an example:

Google Test
Cygwin

Google Test

Of course, we need the Google Test framework.

C++ - Google Test - Setup Visual Studio by hand

Thu, 03 Aug 2017 00:00:00 +0000

Before playing with the Google Test library, it’s necessary to install it.

This is what this tutorial is made of, a bunch of elements in order to set up it.

In our example, we are going to use Visual Studio 2017, so on Windows, without any Command-Line Interface (CLI) nor the RUN_ALL_TESTS() macro.

First of all

Two tools are necessary to realise this Google Test tutorial:

Visual Studio
Google Test

Visual Studio

We admit you have already downloaded Visual Studio 2017, but if not you can always do it.

C++ - Qt Framework - Using Jenkins to generate an .EXE file

Mon, 10 Jul 2017 00:00:00 +0000

In this tutorial we are going to see how to download a project directly on GitHub, generate makefiles of this project, compile it and copy several dynamic-link libraries from a directory to another one.

And all that automatically!

Let’s see this in this Jenkins setup for Qt on Windows with MinGW.

First of all

We’ll use one of my project that I already put on GitHub in order to use it as an example:

C++ - Qt Framework - Moving a shape with arrow keys

Wed, 14 Jun 2017 00:00:00 +0000

Playing with the keyboard is an interesting way of learning the Qt framework.

In this tutorial we are going see, indeed, how to use the arrow keys in order to move a shape.

This shape is a circle, with only few properties to handle with.

Let’s get started.

First of all

In this Qt example we are going to use an interface to specify that our shape is movable.

We’ll also define a constructor for this shape in order to set their useful properties.

C++ - OpenGL - Using the OR and LEFT SHIFT operators to retrieve the display mode with strings

Sun, 30 Aug 2015 00:00:00 +0000

The following tutorial will show you how to exploit data taken from a binary variable.

In order to explain it, we are going to use the GLUT OpenGL library.

The display mode uses indeed this kind of mechanism with the OR operator, symbolized with the famous pipe: “|”.

And we’ll use the LEFT SHIFT operator “«” to check data.

Let’s dive into these binary operators.

First of all

In the GLUT library there are defines in the freeglut_std.h file such as GLUT_RBG, GLUT_INDEX, GLUT_DOUBLE, GLUT_DEPTH, etc.

C++ - OpenGL - Checking the FreeGLUT, GLEW and OpenGL version

Mon, 10 Aug 2015 00:00:00 +0000

First thing to deal with OpenGL is to know which version you have on your operating system.

For this tutorial we will test it on Windows.

And because we are testing the OpenGL version, we will also check what is the FreeGLUT and GLEW version.

Explanation

To create code for OpenGL 3.3, you have to have a graphic card that handles OpenGL 3.3.

If you don’t know which version you have, the code below will show you this.

C++ - OpenGL - Adding an icon to the executable with Visual Studio

Sun, 02 Aug 2015 00:00:00 +0000

To have an executable file that seems professional, it’s necessary to have your own icon when someone launches your program.

This tutorial could easily adapted to any application generated from Visual Studio on Windows.

This icon is generally the logo of the software, game or application you created.

First of all

Creating an ICO file

The icon for the program must be an ICO format.

It means that the extension must be .ico, like for example icon.ico.

C++ - OpenGL - Setting up Visual Studio

Sun, 26 Jul 2015 00:00:00 +0000

The Visual Studio version for this tutorial will be the 2017(seems to work with the 2015 and 2019 as well).
The glew version will be the 2.2.0.
The freeglut version will be the 3.0.0.

The glew library stands for GL E xtension W rangler.

At the end of this OpenGL tutorial you will be able to display a window with a white square displayed on a black background.

First of all

We are going to use the 32-bit or the 64-bit version.

C++ - Algorithm - Using min(), max(), minmax() functions

Sun, 31 May 2015 00:00:00 +0000

To be precise, in this tutorial, we are going to see the min(), max(), minmax(), min_element(), max_element() and minmax_element() functions.

You’ll have no excuse anymore to get the minimum and maximum value from an array or when comparing two variables.

Oh by the way, two functions are taken from the C++ 11: minmax() and minmax_element().

Explanation

The minmax() is a unique function to retrieve min and max values from 2 values or from an entire array.

C++ - Tips'n Tricks - Using interface and abstract classes to compute the shape's area

Sun, 04 Nov 2012 00:00:00 +0000

You’re maybe wondering what are interface and abstract classes? That’s a good point.

In this tutorial we’re going to see how to compute the area of a shape by declaring an array of undefined shapes.

After this, we will be able to use this shape as an object with this kind of Factory design pattern.

Let’s see how with this example of using interface and abstract classes in C++.

Explanation

First of all, let’s create two directories, one for the .hh (headers) and the other for the .cpp (bodies):

C++ - Tips'n Tricks - Creating an object onto the stack and into the heap

Fri, 26 Oct 2012 00:00:00 +0000

Stack and heap enable data management inside the memory.

But some data are added onto the stack and the other into the heap.

For the stack, there is a stack pointer that enables to catch the last data added onto the stack.

It means that the last data added will be the first used by the program. We call that a LIFO (last in, first out) system.

For the heap, this is quite different. Indeed, data added into the heap are added randomly in the RAM by the OS.

C++ - OpenGL - Using glRotatef() to animate shapes

Sat, 14 Jul 2012 00:00:00 +0000

Rotating a shape is fun, but rotating it with animation is really great.

That’s what we are going to see in this glRotatef() tutorial for animating shapes on a window.

Our shape is made up of 3 squares with 3 different colours:

the white
the burgundy
the green

main.cpp

/*
* main.cpp
*/
#include "BadprogRotate.h"
/*
* Main
*/
int main(int ac, char* av[])
{
BadprogRotate go(∾, av);
return 0;
}

BadprogRotate.h

/*
* BadprogRotate.h
*/
#ifndef BADPROGROTATE_H_
#define BADPROGROTATE_H_
#include "GL/freeglut.h"
#include 
#define SCREEN_TITLE "Square rotation by BadproG! :D"
#define SCREEN_WIDTH 600
#define SCREEN_HEIGHT 600
#define SCREEN_POSITION_X 100
#define SCREEN_POSITION_Y 100
class BadprogRotate {
public:
static GLfloat S_ANGLE;
BadprogRotate(int *ac, char *av[]);
virtual ~BadprogRotate();
void init(void);
static void managerDisplay(void);
static void managerIdle(void);
static void managerResize(int, int);
static void managerMouse(int, int, int, int);
static void managerKeyboard(unsigned char, int, int);
};
#endif /* BADPROGROTATE_H_ */

BadprogRotate.cpp

Add the unistd.h file for Windows OS in order to change usleep() by Sleep() in the following managerIdle() method.

C++ - Errors / Warnings - Cannot declare member function ‘static void MyClass::myMethod()’ to have static linkage [-fpermissive]

Thu, 12 Jul 2012 00:00:00 +0000

In C++, we don’t need to specify the static keyword in the declaration of the header and in the definition in the class.

It means that this keyword has to be added only in the header.

You probably know that using the static keyword means that the function is unique in program.
So if you add static in the .h and in the .cpp, you will have like two methods with the same name.
And the compiler won’t appreciate it.

C++ - OpenGL - Creating an equilateral triangle

Sat, 07 Jul 2012 00:00:00 +0000

You succeeded to display a white square on a black background with OpenGL.
Great.
Let’s see now how to render an equilateral triangle and changing some data.

In this example we are going to:

create a Makefile
set the background color to purple
set the drawing color to green (for the triangle)
draw an equilateral triangle on the scene (thanks to the Pythagorean theorem)
put this triangle in the middle of the window
close the window by pressing the ESC key
resize the window on the fly
displaying the x and y of the mouse in the console during a mouse moving
displaying the x and y of the mouse with the state (0 down and 1 up) and which button clicked

All these things are basic to develop a program in OpenGL.
It’s like a super Hello World! tutorial.

C++ - OpenGL - Using glRotatef() to rotate around the X, Y and Z axis

Mon, 04 Jun 2012 00:00:00 +0000

In this OpenGL 2.1 tutorial we are going to use the glRotatef() method.

This method is designed to rotate around the 3 axis: X, Y and Z.
In the example below I will use a black background and draw 3 triangles.

The green will rotate around the X axis.
The blue will rotate around the Y axis.
The red will rotate around the Z axis.

To better understand it, we have to imagine an eye seeing a point.
Now around this point all triangles will rotate.

C++ - OpenGL - Hello World!

Thu, 03 May 2012 00:00:00 +0000

After installing the OpenGL libraries on your system, you would definitely want to display something on the screen.

You are right!

So let’s see this with an Hello World! OpenGL 2.1 tutorial.

This is really a basic code to display a window and saying: “Great I can do it”.
Such basic that it seems C implementation (indeed we don’t have any class in this example).

Code

// badprog.com
#include 
void displayMe(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.5, 0.0, 0.0);
glVertex3f(0.5, 0.5, 0.0);
glVertex3f(0.0, 0.5, 0.0);
glEnd();
glFlush();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE);
glutInitWindowSize(300, 300);
glutInitWindowPosition(100, 100);
glutCreateWindow("Hello world from Badprog.com :D");
glutDisplayFunc(displayMe);
glutMainLoop();
return 0;
}

Compiling

g++ main.cpp -o lookAtThis -lglut ; ./lookAtThis

Result

A black window with a white square displayed.

C++ - OpenGL - Installation

Thu, 03 May 2012 00:00:00 +0000

For this first OpenGL tutorial, we are going to see how to install OpenGL on GNU/Linux and Windows operating system.

We need the OpenGL files, but also those from the GLU and GLUT for GNU/Linux and freeGLUT for Windows.
The last ones, GLU and GLUT are libraries that add functionnalities from the basic OpenGL.

OpenGL = O pen G raphics L ibrary
GLU = G raphic L ibrary U tility
GLUT = G raphic L ibrary U tility T oolkit

Installing OpenGL on GNU/Linux

Fedora

If you do not have the glut.h file in your /usr/include/GL/ directory, let’s install it with the following command on your favorite shell:

C++ - Tips'n Tricks - Using a list of pairs

Wed, 11 Apr 2012 00:00:00 +0000

The container list may accept another container.
For example a pair.

So we are trying to add pairs inside a list. It will become a list of pairs!

In the snippet below, I’m using only one file.
So just compile and execute it to see the result.

Let’s see this by creating a list of pairs in this tutorial.

The file

/* main.c */
#include 


#include 
#include 
class My {
    private:
    std::list < std::pair > _container;
    public:
    My() {
        std::cout << "My created." << std::endl;
        this->containerManager();
    }
    virtual ~My() {
        std::cout << "My destroyed." << std::endl;
    }
    void containerManager() {
        std::cout << "Size of _container = " << this->_container.size() << std::endl;
        this->containerAddElement(std::pair("John", "Gray"));
        this->containerAddElement(std::pair("William", "Blue"));
        this->containerAddElement(std::pair("Charles", "Green"));
        std::cout << "Size of _container = " << this->_container.size() << std::endl << std::endl;
        this->containerDisplayElements();
        this->containerUseFirstElement();
        this->containerDisplayElements();
        this->containerUseFirstElement();
        this->containerDisplayElements();
    }
    void containerAddElement(std::pair myPair) {
        std::cout << "Adding \"" << myPair.first << "\" and \"" << myPair.second << "\" in _container." << std::endl;
        this->_container.push_back(std::pair(myPair.first, myPair.second));
    }
    void containerDisplayElements() {
        int k;
        std::list < std::pair >::iterator it;
        k = 0;
        for (it = this->_container.begin(); it != this->_container.end(); ++it) {
            std::cout << "*it " << k << " = " << (*it).first << " - " << (*it).second << std::endl;
            ++k;
        }
        std::cout << "First element in _container = " << this->_container.front().first << " - " << this->_container.front().second << std::endl << std::endl;
    }
    void containerUseFirstElement() {
        std::cout << "Pop!" << std::endl;
        this->_container.pop_front();
    }
};
int main() {
    My *my = new My();
    delete my;
    while (1337);
    return 0;
}

Result

My created.
Size of _container = 0
Adding "John" and "Gray" in _container.
Adding "William" and "Blue" in _container.
Adding "Charles" and "Green" in _container.
Size of _container = 3
*it 0 = John - Gray
*it 1 = William - Blue
*it 2 = Charles - Green
First element in _container = John - Gray
Pop!
*it 0 = William - Blue
*it 1 = Charles - Green
First element in _container = William - Blue
Pop!
*it 0 = Charles - Green
First element in _container = Charles - Green
My destroyed.

Well done! 🤩

C++ - Algorithm - Using the for_each() function

Thu, 05 Apr 2012 00:00:00 +0000

An example of how using the for_each() function.

Notice that you can have the same result with an iterator, here an example.

#include 
#include 
#include 
void myFunction(int myInt)
{
    std::cout << "myInt = " << myInt << std::endl;
}
int main()
{
    std::vector myVector;
    std::vector::iterator myIterator;
    int i;
    i = 0;
    while (i < 10)
    {
        myVector.push_back(i++);
    }
    for(myIterator = myVector.begin(); myIterator != myVector.end(); ++myIterator)
    {
        if (*myIterator == 2)
        {
            myVector.erase(myIterator);
            myVector.insert(myIterator,  80);
        }
    }
    std::for_each(myVector.begin(), myVector.end(), myFunction);
    return 0;
}

Result:

C++ - Standard library - Using the pair container

Thu, 05 Apr 2012 00:00:00 +0000

The pair container cannot be iterated.

So we can use it for example to return a double value at the end of a function.

In the snippet below we are going to use it to change the first and the second value.
This, respectively with the pair.first and pair.second methods:

#include 
#include 
int main()
{
std::pair myPair(1, "John");
std::cout << "Id: " << myPair.first << " - Name: " << myPair.second << std::endl;
myPair.first = 38;
myPair.second = "William";
std::cout << "Id: " << myPair.first << " - Name: " << myPair.second << std::endl;
return 0;
}

Result:

C++ - STL (Standard Template Library) - Using the queue container

Thu, 05 Apr 2012 00:00:00 +0000

We are going to see in this queue tutorial, how to use it.

Let’s see it with this first snippet.
In the easy example below, we add 10 elements in the queue before displaying its content.
We have to notice that we cannot iterate through a queue.

So we have to use the couple queue.front() and queue.pop() to loop inside the queue.

#include 
#include 
int main()
{
std::queue myQueue;
int i;
i = 0;
while (i < 10)
myQueue.push(i++);
std::cout << "Size of the queue: " << myQueue.size() << std::endl;
std::cout << "First element of the queue: " << myQueue.front() << std::endl;
std::cout << "Last element of the queue: " << myQueue.back() << std::endl;
while (!myQueue.empty())
{
std::cout << myQueue.front() << std::endl;
myQueue.pop();
}
return 0;
}

Result:

C++ - STL (Standard Template Library) - Using the vector container

Thu, 05 Apr 2012 00:00:00 +0000

The vector container is the most classic STL container.

In the snippet below, I can iterate through the vector, so I use an iterator to erase an element of the vector.
In our case, I removed the number 2 from the container and I added 80 to this place.

Let’s see this example of the vector container.

Code

#include 
#include 
int main()
{
  std::vector myVector;
  std::vector::iterator myIterator;
  int i;
  i = 0;
  while (i < 10)
    {
      myVector.push_back(i++);
    }
  for(myIterator = myVector.begin(); myIterator != myVector.end(); ++myIterator)
    {
      if (*myIterator == 2)
        {
          myVector.erase(myIterator);
          myVector.insert(myIterator,  80);
        }
    }
  for(myIterator = myVector.begin(); myIterator != myVector.end(); ++myIterator)
    {
      std::cout << "*myIterator = " << *myIterator << std::endl;
    }
  return 0;
}

Result:

*myIterator = 0
*myIterator = 1
*myIterator = 80
*myIterator = 3
*myIterator = 4
*myIterator = 5
*myIterator = 6
*myIterator = 7
*myIterator = 8
*myIterator = 9

A really helpful container! 😇

C++ - Tips'n Tricks - Converting a std:string into an int and converting an int to a std::string

Fri, 10 Feb 2012 00:00:00 +0000

For the C, we had the famous atoi() function, but for C++, how can I convert a std::string into an int?

That’s a great question, and the answer is easy, with the std::stringstream type element.

In this tutorial, we will see how to convert a std::string into an int and how to convert an int to a std::string.

Let’s start by converting a string into a number (an int):

1. Converting a std::string into an int

So, let’s take an example of this conversion:

C++ - Errors / Warnings - After compiling

Sun, 15 Jan 2012 00:00:00 +0000

As the same for the C - Error / Warning section, I made this one to summarize common mistakes when I tried to compile my code.

So let’s go to see some good errors and warnings in C++ (I’m sure it is also a great moment for you when you discovered these errors).

1. Main.cpp:(.text+0x1f): undefined reference to `Parent::Parent()'

A. The problem

A very common error!
Did you include the parent.cpp file in your Makefile?
Did you compile with this parent.cpp?

C++ - Keyword - virtual

Sun, 15 Jan 2012 00:00:00 +0000

The virtual keyword is used in different ways in C++.

The most common way to use it is before a destructor.
Indeed, with this virtual keyword we can specified that the children of a class will be deleted before its parent.

Let’s see it with a tutorial.

1. virtual before a destructor

In this example, I created two classes, a Parent and a Child. So Child inherits from Parent.

The headers:

C++ - Makefile - Adding flags

Sun, 15 Jan 2012 00:00:00 +0000

A personal Makefile is sometimes better than a Makefile generated by default by your IDE, such Eclipse or Visual Studio C++ for example.

If you don’t know how to create one, let’s see it in this easy example of Makefile for C++.
I added some flags for the variable CXXFLAGS, it is different from the C language, where it is CFLAGS.

With g++, you do not have to write the variable CXXFLAGS in your compilation line, but if you prefer, you can add it.

C++ - Qt Framework - Hello World

Tue, 18 Oct 2011 00:00:00 +0000

Now that you have already installed Eclipse, Qt Framework Open Source and MinGW with the this tutorial, we will create our first program window.

Let’s go.

1. Hello World on Windows OS

Open Eclipse, on the Explorer > Right Click > New Project > Qt > Qt Gui Project.
Write a project name such as hello-world, then Next, Next, Finish.

A lot of files and directories are created for you.
Delete all.

C++ - Windows - Hello World!

Sun, 02 Oct 2011 00:00:00 +0000

Let’s create our first C++ application.

For this tutorial, we will use:

Eclipse Indigo CDT
Cygwin

If you install your Cygwin binary into a different drive than from your development directory you can still use it.
For example if you have installed Cygwin in C:/soft/ and want to work in D:/dev/, go until C:/soft/ and run your Cygwin.bat file.
Once open, write it:

cd /cygdrive/

then press the TAB key on your keyboard.
You have now access to all your drives.

C++ - Eclipse - Installation of C/C++ Development Tools (CDT) and Cygwin for Windows

Tue, 20 Sep 2011 00:00:00 +0000

In this tutorial of Eclipse, we will install C and C++ on Windows with some examples.

Easy?

Not really, but nothing is impossible of course!

Why?

Because Windows needs another software to create and manipulate C and C++.
This software is Cygwin.

1. Installing Cygwin

So let’s download it on the official website: http://www.cygwin.com/

If you download all files available with Cygwin, prepare yourself to wait several hours.
Indeed, you will need at least 7GB of data.

Cpps on BadproG

C++ - NVIDIA CUDA - Using the compute_xy and sm_xy compile options to generate an executable

C++ - Qt Framework - Mixing native OpenGL functions with Qt ones

First to all

C++ - Qt Framework - Using QOpenGLWidget to display a shape with lighting and normal vectors

C++ - OpenCV - Hello world

Firs​t of all

C++ - OpenCV - Setting up with Visual Studio

First of all

C++ - Qt Framework - Using QOpenGLWidget to display a window for moving shapes with keyboard and mouse

C++ - Qt Framework - Using OpenGL texture with index array

First of all

C++ - Qt Framework - Using 1 OpenGL VAO and 2 VBOs with only 1 array for both position and color of each vertex

First of all

C++ - Qt Framework - Using OpenGL VAO and VBO to handle 2 different objects on the scene

C++ - Boost - Converting std::vector to Boost.Python Numpy ndarray

First of all

C++ - Boost - Using Boost.Python Numpy from_data()

First of all

C++ - Boost - Building the Boost.Python NumPy extension as a library

First of all

C++ - Boost - Using Boost.Python library on Windows to create a DLL

First of all

C++ - Boost - Setting up on Windows 10

C++ - Qt Framework - Using QStyledItemDelegate for displaying a QCheckBox in a QTableView

First of all

C++ - Windows - Creating a dynamic-link library (DLL)

First of all

C++ - Qt Framework - Using QAbstractItemModel with QTableView and QListView

First of all

C++ - Qt Framework - Using QDataStream

First of all

C++ - Visual Studio IDE - Sharing project property sheets on many projects

First of all

C++ - Design pattern - Command

First of all

C++ - Design pattern - Memento

First of all

C++ - Design pattern - Strategy

First of all

C++ - Design pattern - Proxy

C++ - Design pattern - Mediator

First of all

C++ - Standard library - move

First of all

C++ - Design pattern - Decorator

C++ - Design pattern - Prototype

First of all

C++ - Design pattern - Factory method

First of all

C++ - Design pattern - Singleton

C++ - Design pattern - Observer

C++ - CMake - Setup with Cygwin

C++ - Google Test - Set up projects to use the gtest library

First of all

C++ - Google Test - Generating the gtest.lib from gtest.sln with Visual Studio

First of all

C++ - Google Test - Using a Makefile to generate tests

First of all

Google Test

C++ - Google Test - Setup Visual Studio by hand

First of all

Visual Studio

C++ - Qt Framework - Using Jenkins to generate an .EXE file

First of all

C++ - Qt Framework - Moving a shape with arrow keys

First of all

C++ - OpenGL - Using the OR and LEFT SHIFT operators to retrieve the display mode with strings

First of all

C++ - OpenGL - Checking the FreeGLUT, GLEW and OpenGL version

Explanation

C++ - OpenGL - Adding an icon to the executable with Visual Studio

First of all

Creating an ICO file

C++ - OpenGL - Setting up Visual Studio

First of all

C++ - Algorithm - Using min(), max(), minmax() functions

Explanation

C++ - Tips'n Tricks - Using interface and abstract classes to compute the shape's area

Explanation

First of all