Is there a way to down cast a struct to its derived one in C++?

Question

Here is my situation:

struct A {
    int numberAllChildStructsUse;
}

struct B : A {
    std::string strUniqueToB;
}

struct C : A {
    std::string strUniqueToC;
}

(in some source file)

B b = thisFunctionReturnsBOrCStructsAsTypeA(int idThatGuaranteesItIsTypeBNotC);

Error: no suitable user-defined conversion from A to B exists when I try that above line. What is the best way to get this to work? Struct A represents the commonalities that all Bs, Cs share. The member vars inside of B and C are unique to each other. That function returns A type structs, but I know that they are actually in fact either Bs or Cs, and can tell based off of the parameter I supply.

dynamic_cast is used to cast between objects which are part of the same hierarchy https://en.cppreference.com/w/cpp/language/dynamic_cast — Luiz, Aug 03 '21 at 13:20
If you know at the callsite what type the function will return, you could perhaps make it into two separate functions. `thisFunctionReturnsB` and `thisFunctionReturnsC`. — Ted Lyngmo, Aug 03 '21 at 13:21
I do have those two functions as well, but I wanted for simplicities sake to be able to have one function that finds all the structs (there are like 20). So I wouldn't have to write 20 different thisFunctionReturns_ funcs — dmscs, Aug 03 '21 at 13:22
If this issue never cropped up and I was in C# or something I could just have done "B b = returnsAnyStruct() as B" :P then it would have been simple — dmscs, Aug 03 '21 at 13:27
You still need to return a pointer or reference instead of a value, since currently you'll be slicing out just the base-class subobject. — Useless, Aug 03 '21 at 13:32
@dmscs In C#, those classes would have all been heap-allocated and would have associated vtables. This is all possible to do in C++ too, but they are not done by default because they have significant overhead. If you make your classes polymorphic and return a `unique_ptr` or `shared_ptr ` from your function, it will be just as simple as it is in C#. That is not idiomatic C++ way of doing things though. If you add more details about what exactly you are trying to solve, we can show you better ways to do that in C++. — Aykhan Hagverdili, Aug 03 '21 at 13:53
It seems that dynamic casting is working for me. I tried unique/shared pointers, but I got an error which I forget now what it was. The function I mentioned in the body now returns the address of whatever struct it finds. With the address, I can make a dynamic_cast to a B* or C* etc. Really, I just have a ton of structs (like 20 different types) and wanted a single function that gets all of them (in a std::map) and finds the one I am looking for. I know at the callsite what type the result should be based off the supplied ID parameter so I think I can get away with dynamic casting — dmscs, Aug 03 '21 at 14:06

score 3 · Answer 1 · answered Aug 03 '21 at 13:39

If your function returns by value, slicing possibly happens and you can't get a B.

If your function returns a reference or a pointer, you have 2 options:

If you are absolutely certain that the dynamic type is a pointer/reference to B, you can use static_cast. It has zero overhead, but if you get the type wrong you get UB.
If you are not sure if the dynamic type is a pointer/reference to B, and your type is polymorphic (has a virtual function), then you can use dynamic_cast. It will report the error so you can handle the failure case at the cost of some overhead. In my experience, dynamic_cast is often a sign of poor design, so be careful not to obfuscate stuff.

score 2 · Accepted Answer · answered Aug 03 '21 at 13:20

2

You can use dynamic_cast for this, but only if the class hierarchy is polymorphic.

To achieve the latter, write

struct A {
    int numberAllChildStructsUse;
    virtual ~A() = default;
};

reference: https://en.cppreference.com/w/cpp/language/dynamic_cast

answered Aug 03 '21 at 13:20

Bathsheba

231,907
34
361
483

1

It is worth mentioning that more often than not `dynamic_cast` tends to point to flaws in design. Ideally, when IS-A principle is properly observed, this cast is not required. – SergeyA Aug 03 '21 at 13:23
Thank you. Why is it important that its polymorphic? – dmscs Aug 03 '21 at 13:24
@dmscs:If it's not polymorphic then `dynamic_cast` doesn't work. If you want a polymorphic type then you probably also want a virtual destructor. The technique I give kills both these birds with one stone. – Bathsheba Aug 03 '21 at 13:25

Is there a way to down cast a struct to its derived one in C++?

2 Answers2