What type to set if I want to return SFML drawable objects?

[sfmluser1]

Hello everyone!  I have a question. I'm new to C++ and SFML. How can I return any drawable object in one type? i.e:

// what type?
sfml_drawable? function(int x) {
    if(x == 1) {
        sf::RectangleShape rect(some_args);

        return rect;
    } else if(x == 2) {
        sf::CircleShape circl(some_args);

        return circl;
    }
}

function(1) // => sf::RectangleShape
function(2) // => sf::CircleShape
 

Please help me

[Hapax]

Hi!
And welcome!

It is possible using casting but it's clunky and very easy to cause errors if it's not perfectly designed.

I suppose the question that should be asked here is: why do you need to do that?

That is, there may be a better, simpler and more safe way of doing it.

[sfmluser1]

Basically I have function that generates SFML object from LevelObject (template). i.e

void draw(LevelObject obj, sf::RenderWindow &window) {
    if(obj.type == RECTANGLE) {
         sf::RectangleShape rect(obj.width, obj.height);

        window.draw(rect);
    } // other types
}
 

So now I'd like to return generated sfml object, for future export object properties to file, and later load them. Also later I'd like to create vector that will contain all loaded objects from file, but the same problem remains. What vector type should I have? I tried std::variant:

using ExportableSFMLObject = std::variant<sf::RectangleShape, sf::CircleShape, sf::Text, sf::Sprite, int>;

ExportableSFMLObject function(...) { ... }
 

But then I couldn't figure out exactly what type function returns, maybe it's RectangleShape, or sf::CircleShape. Even if I could resolve what type function returns, function GetType, where'd I'd like to realize type resolving, is also doesn't have exact type to return.

[sfmluser1]

It's the main problem in my project

[Hapax]

I was thinking about a union, although I'd probably use a union of pointers, so I can understand why you' ve chosen std::variant.

It turns out that you can check a variant's type (from it's "alternatives" that you have provided) by getting the index of the alternative:
https://en.cppreference.com/w/cpp/utility/variant/index

So, it'd be something like:

switch (ExportableSFMLObject.index())
{
    case 0u:
        // it is an sf::RectangleShape
    break;
    case 1u:
        // it is an sf::CircleShape
    break;
    case 2u:
        // it is an sf::Text
    break;
    case 3u:
        // it is an sf::Sprite
    break;
    case 4u:
        // it is an int
    break;
}

Or, indeed, maybe this:

if (std::holds_alternative<sf::RectangleShape>(ExportableSFMLObject))
    ; // it is an sf::RectangleShape
else if (std::holds_alternative<sf::CircleShape>(ExportableSFMLObject))
    ; // it is an sf::CircleShape
else if (std::holds_alternative<sf::Text>(ExportableSFMLObject))
    ; // it is an sf::Text
else if (std::holds_alternative<sf::Sprite>(ExportableSFMLObject))
    ; // it is an sf::Sprite
else if (std::holds_alternative<int>(ExportableSFMLObject))
    ; // it is an sf::int

It's worth noting that I've not test this.

[sfmluser1]

I think its going to work! But is it possible to contain type resolving code in function? Or like I said it's impossible because there is no exact type?

[Hapax]

What exactly do you want the function to return?

If it's LevelObject::obj, you can set it from the index using similar code to above.

e.g.

LevelObject::type getLevelObjectType(ExportableSFMLObject& xObj) const
{
    switch(xObj.index())
    {
        case 0u:
            return RECTANGLE;
        case 1u:
            return CIRCLE;
        case 2u:
            return TEXT;
        case 3u:
            return SPRITE;
        case 4u:
            return INT;
    }
}

...or whatever you named them

[sfmluser1]

I mean getType function should return SFML drawable class:

??? getType(ExportableSFMLObject obj) {
    if (std::holds_alternative<sf::RectangleShape>(obj))
        ; // it is an sf::RectangleShape
        // return sf::RectangleShape
    else if (std::holds_alternative<sf::CircleShape>(obj))
        ; // it is an sf::CircleShape
        // return sf::CircleShape
    else if (std::holds_alternative<sf::Text>(obj))
        ; // it is an sf::Text
        // etc
    else if (std::holds_alternative<sf::Sprite>(obj))
        ; // it is an sf::Sprite
    else if (std::holds_alternative<int>(obj))
        ; // it is an sf::int
}
 

[Hapax]

So not the type but the object itself?

Then you'll likely need function overloading or templates.

Saying that, why do you need to do that if the variant already holds the object and you can just use the index (or my function) to know which type.

[sfmluser1]

I'm very sorry I know what is a template or method overloading, but I don't know how to implement this. It would been easier if std::variant<v1, v2> returned exactly v1 or v2, not std::variant. So for example how do I implement method overloading if I have only one type? (ExportedSFMLObject). I'm sorry I don't understand

[Hapax]

Well, the problem you have is that you can't return one item or the other, you can return a variant that contains one or the other; that seems to be what it's for.

Function-wise, the simplest solution would just be to be more explicit.

switch(xObj.index()) // as above
{
    case 0u:
        doStuffWithRectangleShape(xObj);
    // etc.
}

but overloading could look like this:

doStuffWithXObj(xObj.get());

where it would call whichever function is required for the type:

void doStuffWithXObj(sf::RectangleShape& rectangleShape);
void doStuffWithXObj(sf::CircleShape& circleShape);
// etc.

[sfmluser1]

I'm going to completely rethink some feature implementations because I don't think I can fix this bug. Thank you for helping, I very appreciate it!

[Hapax]

It's likely you should rethink the design so this isn't necessary.
If you have a function that is returning an unknown object, what are you doing with that object where you don't need to then know what the type is before you use it?

But...

If you absolutely must return an unknown drawable, you can cast.
Warning! This is 'dangerous' and my example is likely to not be fully safe.

Note that this is only really useful if you actually don't need to know its type (and only using base class stuff)

sf::Drawable* makeThing(const std::size_t whichThing)
{
    switch (whichThing)
    {
        case 0u:
            sf::Rectangle rectangle;
            return dynamic_cast<sf::Drawable*>(&rectangle);
        break;
        case 1u:
            sf::CircleShape circle;
            return dynamic_cast<sf::Drawable*>(&circle);
        break;
    }
}

sf::Drawable* thing1{ makeThing(0u) };
window.draw(*thing1); // a rectangle
sf::Drawable* thing2{ makeThing(1u) };
window.draw(*thing2); // a circle

Or something...
But you'd still need to know which thing it is if you need to do specific things (e.g. if you need to set the circle's radius).
And you'd need to cast it back.


Not certain if this code is sound either so I take no responsibility in any issues causes by using it