Intermediaware » Beautiful hacks

C/C++: Pseudo Loops

Joe — Fri, 29 Mar 2013 04:24:57 +0000

Do you think the loop inside following code does make any sense? Well, it does, because you can break out of it in a very elegant way:

You also will see something like that very often in macros. This is because, something like that: will expand into this: And this will produce an error. If you put a pseudo loop around it, everything works fine:

Hack Of The Day: C++ Class Method Pointers

Joe — Wed, 07 Dec 2011 15:13:48 +0000

Function pointers are very handy in C++. But they don't work on class methods, here is a neat workaround, that even works with virtual methods.

Hack of the day: Hello World in Paint

Joe — Sat, 16 Apr 2011 22:29:32 +0000

What is your favorite IDE/Editor for coding C++? Well, it seems like some programmers prefer Paint over Visual Studio:

Hack of the day: Render circles without trigonometry

Joe — Sat, 12 Mar 2011 22:12:34 +0000

The Bresenham line algorithm avoids trigonometry and uses integer math to calculate the points of a line, circle or ellipse. Here is a small example (implemented in C++ / SFML):

#include 

void drawEllipse(sf::RenderWindow &w, int cx, int cy, int r1, int r2) {
    sf::Shape point = sf::Shape::Circle(0, 0, 1, sf::Color::White);
    
    int x = -r1, y = 0;
    int err = r1 * r1 - (2 * r1 - 1) * r2 * r2, e2;
    
    do {
        point.SetPosition(cx - x, cy + y) ; w.Draw(point);
        point.SetPosition(cx + x, cy + y) ; w.Draw(point);
        point.SetPosition(cx + x, cy - y) ; w.Draw(point);
        point.SetPosition(cx - x, cy - y) ; w.Draw(point);
    
        e2 = 2 * err;
        
        if (e2 >= (x * 2 + 1) * r2 * r2)
            err += (++x * 2 + 1) * r2 * r2;
        
        if (e2 

To learn more about the theory behind the algorithm, please have a look at the Midpoint Circle Algorithm at Wikipedia.

Hack of the day: Array-like access to fields

Joe — Sat, 26 Feb 2011 02:12:23 +0000

Sometimes it is useful if you are able to access fields of a struct or class as an array. For example, if you have the following struct:

struct Point3D {
    float x,y,z;
};

but you require to access the x,y and z-fields as an array, you can use an union:

union Point3D {
    float coord[3];
    struct {
        float x,y,z;
    };
};

Point3D p;
p.x = 1;
p.coord[1] = 2; // the same as  p.y = 2;
p.z = 3;

Another possibility is to create a class and overload the []-operator:

class Point3D {
public:
    float& operator[](int x) { 
        assert(x <= 2 && x >= 0); 
        if (x == 0) return this->x; 
        if (x == 1) return this->y; 
        return this->z;
    }

    float x,y,z;
};

Point3D p;
p.x = 1;
p[1] = 2;
p.z = 3;

Hack of the day: Use references for parameter passing

Joe — Fri, 25 Feb 2011 04:33:03 +0000

If you have functions with lots of parameters you should consider using a struct or class and pass the parameters by reference. A reference or pointer is 4 bytes (on 32Bit systems). A function or method with a lot of parameters passed by value is more expansive than passing by reference because each parameter is copied on the stack. If you have complex parameters like classes you should never pass them by value, because the constructors and destructors will be invoked. Pass by value:

int doStuff(int a, int b) {
    return a + b;
}

doStuff(1, 2);

Pass by reference:

struct someData {
    int a, b;
};

int doStuff(const someData &foo) {
    return foo.a + foo.b;
}

someData foo;
foo.a = 1;
foo.b = 2;

doStuff(foo);

Hack of the day: Access private members in unit tests

Joe — Thu, 17 Feb 2011 15:32:02 +0000

Sometimes it could be very useful to be able to test private members or methods in your unit tests. But how could this be achieved? In C/C++ you can do this by using a simple macro:

#define protected public
#define private public

Hack of the day: Interfaces in C++

Joe — Fri, 04 Feb 2011 19:06:37 +0000

I lately talked with a friend about which language is the best and he told me that C++ doesn't have Interfaces like Java. Well, that's no true, you can create Interfaces in C++ like this:

#include 

class IRenderable {
public:
    virtual ~IRenderable() {}
    virtual void Render() = 0;
};

class MyRendererableNode : public IRenderable {
public:
    virtual void Render() {
        std::cout << "Rendering stuff..." << std::endl;
    }
};

int main (int argc, char * const argv[]) {
    // IRenderable foo; <-- this is not allowed
    MyRendererableNode foo;
    foo.Render();
}

Don't forget the virtual destructor, so the following code won't do strange things:

IRenderable *foo = new MyRendererableNode();
foo->Render();
delete foo, foo = NULL;

Hack of the day: Safe delete

Joe — Thu, 03 Feb 2011 22:48:29 +0000

If you free up memory in C++, you should also set the pointer to NULL. If you double delete memory, your application will crash! Because I'm a lazy coder, I'm using a macro or template in nearly every of my C++-Projects to get rid of it:

template
inline void safeDelete (T*& p) { 
    delete p; 
    p = NULL; 
}

Hack of the day: Random sort

Joe — Wed, 02 Feb 2011 03:00:42 +0000

@dennisosimon and myself are currently prototyping various things using haxe. Today we wanted to shuffle the elements of an array around. As haxe doesn't support a shuffle-method for arrays out of the box, we came up with a very simple workaround: Haxe provides an easy way to sort items. You can use the sort-method with a function pointer as parameter to sort the elements according to your own comparison function. What we've done is, that we simply just returned random values to achieve some kind of random sort algorithm:

var indices:Array = new Array();
for (i in 1...13) {
    indices.push(i);
}
indices.sort(randomSort);

private function randomSort(x:Int, y:Int):Int {
    return Math.random() > 0.5 ? 1 : -1;
}

While this seems like a very easy solution with only a few lines of code, Pimm Hogeling and @43ryn pointed out, that it isn't a good idea to use it, because in the worst case it could end in an infinite loop. You can read about the details here. A better and also fast way is to implement the Fisher–Yates shuffle:

public function shuffleArray(arr : Array) { 
    var tmp : Int, j : Int, i : Int = arr.length;
    while (i > 0) {
        j = Std.int(Math.random() * i);
        tmp = arr[--i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}