How to avoid calling the destructor twice when using a factory function with a std::expected return without runtime costs

Question

It's about embedded C++. Let's assume I have a struct Timer_t.

To create a new object

the constructor is private
we have a factory-function as a public member makeTimer()

We can't use exceptions on the device and to intiailize the Timer we can get errors.

That's why

the default constructors are hidden for the user
a factory function is used
the factory function returns std::expected<Timer_t,Error_t>

Since we use C++ and people tend to fail (calling me out here too often)

Constructors are powerful to initialize
Destructors are powerful to deinitialize

Constructors are only half usable here, the factory function is this for us.

For the destructor it works nice. If we ever leave the scope we deinitialize it. That's how it should be.

Now the problem starts: if we return in makeTimer() the Object we have a move.

To be more precise we call the move constructor!

Therefore we have 2 objects and for the object we call the destructor.

To be more precise:

makeTimer() -> Timer_t() -> std::move/Timer_t(Timer_t &&) -> ~Timer_t() ->  program ends -> ~Timer_t();

For a move, this is the expected behaviour. Therefore it's per standard correct, but annoying.

In context of embedded I see there a big risk that people will fail here when extending the code.

I only want to call the destructor once at the end.

if I use Timer_t as a return it works! (that's what is frustrating)
I forbid to use non-trivial types (ugh! or i never saw a good example for this specific Timer thing)
use Error_t makeTimer(Timer_t & uninitialized Type) (Would kill the idea behind std::expected and makes code less "nice")
use a flag/counter like std::shared_ptr (extra costs...) or a simple bool.

Is there a better cleaner idea to solve that problem? I can't be the only one with it.

Are you sure there is a move? (N)RVO may optimise it away, depending on your actual code. — Yksisarvinen, Jun 12 '23 at 12:41
Why would you ever destroy a timer resource in an embedded system? That doesn't make any sense. It's not a PC. — Lundin, Jun 13 '23 at 14:44
@Yksisarvinen after the explaination not anymore. But RVO is removing the destructor and thats what i wanted — Sickeroni, Jun 15 '23 at 10:40
@Lundin Offtopic... But to answer it. it makes sense in evnironments, where you have different operation modes (commisioning, setupmode etc), also it's the first step for some(!) pwm drivers, that could be used for blinking or fading LEDs. — Sickeroni, Jun 15 '23 at 10:43

Jan Schultke · Accepted Answer · 2023-06-12T13:01:46.680

Thanks to RVO (return value optimization), the problem you're describing doesn't really exist in C++. Consider the following code:

#include <expected>

struct Timer_t {
    Timer_t();
    Timer_t(Timer_t&&);
    Timer_t& operator=(Timer_t&&);
    ~Timer_t();
};

struct Error_t {
    Error_t();
    Error_t(Error_t&&);
    Error_t& operator=(Error_t&&);
    ~Error_t();
}; 

std::expected<Timer_t, Error_t> makeTimer() {
    return {};
}

int main() {
    auto timer = makeTimer();
}

Without RVO, it looks like return {} first has to create a default-constructed std::expected, which would call Timer_t(), and then auto timer = makeTimer(); would call the move constructor because the right hand side is a prvalue.

However, that's not how it works since C++17:

auto timer = makeTimer() is subject to copy elision, so no move constructor is being called.
in return {};, because the {} is a prvalue with the same type as the return type, it is subject to RVO.

Both of these optimizations are mandatory, so it is guaranteed that we are only calling Timer_t() once, and then ~Timer_t() when timer goes out of scope. As expected, this is the compiler output:

main:
        sub     rsp, 24
        lea     rdi, [rsp+14]
        call    Timer_t::Timer_t() [complete object constructor]
        lea     rdi, [rsp+14]
        mov     BYTE PTR [rsp+15], 1
        call    Timer_t::~Timer_t() [complete object destructor]
        xor     eax, eax
        add     rsp, 24
        ret

See live example using GCC 13 with -std=c++2b -O2.

THANKS! Fast, very precise perfect answer! – Sickeroni Jun 12 '23 at 14:29 — Sickeroni, Jun 12 '23 at 14:29

How to avoid calling the destructor twice when using a factory function with a std::expected return without runtime costs

1 Answers1