Implementing abstract 'overlaps' method for different shapes? - c++

Question

I have an abstract base class called Shape, which looks something like this:
class Shape {
public:
Shape(Point center);
virtual bool overlaps(Shape *other) = 0;
private:
Point m_center; // has getter&setter
};
I'm having problems with the overlaps(Shape *other); method; I have no idea how to implement it in subclasses.
Let's take two examples, (I will probably have no more than two or three shapes) Circle and Rect.
Basically what I've tried is to create a two overloads in both classes after using forward declaration to allow Circle and Rect to "know" each other:
virtual bool Rect::overlaps(Circle *other);
virtual bool Rect::overlaps(Rect *other);
virtual bool Circle::overlaps(Circle *other);
virtual bool Circle::overlaps(Rect *other) { return other->overlaps(this); }
It's now easy to implement the maths inside all the overloads; however, I will get an error cannot allocate an object of abstract type 'Circle' and note: virtual bool Unit::overlaps(Unit *).
This is because my Circle and Rect classes only have methods with Circle * and Rect * as their parameters, but none with Unit *.
I also tried forward declarating Circle and Rect in my shape.h, but since forward declarations aren't the same classes as my actual Circle and Rect, I will only get the same error.
Without removing the common base class, is there a way to implement such behavior?
Or is there a workaround to make it work?
Additional Information
I have a 2D World class which contains vector<Shape *> m_shapes; and I will need to see if two shapes overlap each other;
for (unsigned int i = 0; i < m_shapes.size(); i++) {
if (certainShape->overlaps(m_shapes[i])) {
collapse();
}
}

Answer 1

Welcome to multiple dispatch! Essentially, you are asking for a method that is virtual with respect to the runtime type of more than one object - in your case, the types of two shapes being tested for overlap.
There are several common ways of implementing double dispatch in C++: for example, you could use the visitor pattern, or make a map based on RTTI. Selecting one or the other is up to you.
If you decide to go with the visitor pattern, you make the Shape "visitable" by adding the visit method.
Here is an example of the visitor-based approach. It is admittedly rather verbose, but it also addresses a complex task, so it is fair for it to require lots of code. I stripped the example below to the bare minimum - only two shapes with no data members, and methods that do not do anything except printing. This should be sufficient to get you started, though:
#include <iostream>
using namespace std;
class ShapeVisitor;
struct Shape {
virtual void accept(ShapeVisitor& v) = 0;
virtual bool overlaps(Shape& other) = 0;
};
class Circle;
class Square;
struct ShapeVisitor {
virtual void visitCircle(Circle& c) = 0;
virtual void visitSquare(Square& s) = 0;
};
// These three methods do the actual work
bool checkOverlap(Square& s, Circle& c) {
cout << "Checking if square overlaps circle" << endl;
return false;
}
bool checkOverlap(Square& a, Square& b) {
cout << "Checking if square overlaps square" << endl;
return false;
}
bool checkOverlap(Circle& a, Circle& b) {
cout << "Checking if circle overlaps circle" << endl;
return false;
}
class Square : public Shape {
struct OverlapVisitor : public ShapeVisitor {
OverlapVisitor(Square& _my) : result(false), my(_my) {}
virtual void visitCircle(Circle& c) {
result = checkOverlap(my, c);
}
virtual void visitSquare(Square& s) {
result = checkOverlap(my, s);
}
bool result;
Square& my;
};
public:
virtual void accept(ShapeVisitor& v) {
v.visitSquare(*this);
}
virtual bool overlaps(Shape& other) {
OverlapVisitor v(*this);
other.accept(v);
return v.result;
}
};
class Circle : public Shape {
struct OverlapVisitor : public ShapeVisitor {
OverlapVisitor(Circle& _my) : result(false), my(_my) {}
virtual void visitCircle(Circle& c) {
result = checkOverlap(my, c);
}
virtual void visitSquare(Square& s) {
// Important: note how I switched the order of arguments
// compared to Square::OverlapVisitor! There is only one
// square/circle overlap function checker, and it expects
// the square to be the first argument.
result = checkOverlap(s, my);
}
bool result;
Circle& my;
};
public:
virtual void accept(ShapeVisitor& v) {
v.visitCircle(*this);
}
virtual bool overlaps(Shape& other) {
OverlapVisitor v(*this);
other.accept(v);
return v.result;
}
};
Here is this running demo on ideone.
With RTTI approach you would make a map<pair<type_info,type_info>,checker> where checker is a type of a function that takes two pointers to Shape, and returns true or false depending on whether or not the shapes overlap. You make one such function for each pair of object types, populate the map with pointers to these functions based on type_info of their expected parameter types, and use this map at runtime to call the desired function.
Item 31 of the More Effective C++ book explains both these approaches in depth, with some great examples. In fact, the use case discussed in the book, detecting collisions between a pair of game objects, is similar to the one that you are implementing.

Answer 2

What you need is a "how big is other" type function. If we make it real simple, and just use a bounding box (a rectangle that is big enough to cover the entire shape), then we could do something like this:
(For simplicy, I'm using rect as a term for a rectangle)
class Shape
{
...
virtual rect BoundingBox() = 0;
bool overlaps(const Shape& other)
{
return BoundingBox.FitsInside(other.BoundingBox());
}
};
Obviously, you'll then have to write the function of fitsinside for two rectangles and BoundingBox for each shape, but it shouldn't be too hard.
To make a "is this Star completely covered by this Oval?" makes for a slightly more challenging solution [you will need to have a complete outline of both shapes, and an Oval outline may be quite a lot of points to be precisely oval].

Answer 3

Making the subclasses know about each other is a bad idea. If you want pixel-perfect collision, then you are going to have to iterate through every pixel in the shape and compare with the other shape's pixels. Create a virtual function to get a pixel N from the shape, where N is an index, and another function to return the number of pixels. For each pixel N in the current shape, compare with all pixels 0..Nmax in the other shape for collision.
The order of pixels from the index N can be any order. If you alternate pixels between different sides of the shape over nearby N, and start with the outer pixels first, you may be more likely to detect a collision on a lower N.
Now this simple approach is slow, especially if you have many shapes. The solution is to use a cheaper algorithm to check whether the perfect algorithm is necessary. A rectangle bounding box is the cheapest way. Work out the coordinates of a rectangle which is just large enough to hold your shape. I don't know how to work this out for a circle (geometry not my strong suit). You could even cache the bounding box sizes in the class to prevent recalculation for complex shapes. Checking whether two rectangles overlap is very quick and easy.
Only then move onto the costly algorithm if the bounding boxes overlap.
You can make faster checks between certain pairs of objects. For example, two rectangles overlap if their bounding boxes do. It's overkill to move onto pixel comparison. But you may not need this level of performance.