How to pass a variant as constructor parameter or as function argument

Question

I am reading about implementation of state machines using variants. I try to create a construction that take a variant parameter to initialize the state. However whent the constructor is defined , I get a warning that this is recognized as function declaration.

Moreover when I try to define a setter for the state, compiler error is generated when try to call this

Here is the code

#include "pch.h"
#include <iostream>
#include <variant>
#include <cassert>

struct DoorState
{
    struct DoorOpened {};
    struct DoorClosed {};
    struct DoorLocked {};

    using State = std::variant<DoorOpened, DoorClosed, DoorLocked>;
    DoorState()
    {
    }
    DoorState(State & state)
    {
        m_state = state;
    }
    void open()
    {
        m_state = std::visit(OpenEvent{}, m_state);
    }

    void close()
    {
        m_state = std::visit(CloseEvent{}, m_state);
    }

    void lock()
    {
        m_state = std::visit(LockEvent{}, m_state);
    }

    void unlock()
    {
        m_state = std::visit(UnlockEvent{}, m_state);
    }

    struct OpenEvent
    {
        State operator()(const DoorOpened&) { return DoorOpened(); }
        State operator()(const DoorClosed&) { return DoorOpened(); }
        // cannot open locked doors
        State operator()(const DoorLocked&) { return DoorLocked(); }
    };

    struct CloseEvent
    {
        State operator()(const DoorOpened&) { return DoorClosed(); }
        State operator()(const DoorClosed&) { return DoorClosed(); }
        State operator()(const DoorLocked&) { return DoorLocked(); }
    };

    struct LockEvent
    {
        // cannot lock opened doors
        State operator()(const DoorOpened&) 
        { 
            std::cout << "DoorOpened" << std::endl;
            return DoorOpened(); 
        }
        State operator()(const DoorClosed&) { return DoorLocked(); }
        State operator()(const DoorLocked&) { return DoorLocked(); }
    };

    struct UnlockEvent
    {
        // cannot unlock opened doors
        State operator()(const DoorOpened&) { return DoorOpened(); }
        State operator()(const DoorClosed&) { return DoorClosed(); }
        // unlock
        State operator()(const DoorLocked&) { return DoorClosed(); }
    };
    void set(State state)
    {
    }
    State m_state;
};

int main()
{
    //DoorState s(DoorState::DoorOpened);
    DoorState s; 
    s.set(DoorState::DoorOpened);
    s.lock();
    return 0;
}

Did you try `DoorState s((DoorState::DoorOpened));` or `DoorState s{DoorState::DoorOpened};` instead? (These are the usual tricks in this case.) ([SO: Avoid the most vexing parse](https://stackoverflow.com/a/13249766/7478597)) — Scheff's Cat, Jun 22 '19 at 16:15
Without vexing parse, it would be `DoorState s(DoorState::DoorOpened());` (as state in answer, you need instance but you only provide type) but because of vexing parse, you have to use alternative as `DoorState s{DoorState::DoorOpened{}};` — Jarod42, Jun 22 '19 at 19:29
`compiler error is generated` It might be helpful to know what that error is. — , Jun 23 '19 at 05:24

CuriouslyRecurringThoughts · Accepted Answer · 2019-06-22T19:45:09.990

2

In

s.set(DoorState::DoorOpened);

you are passing a type, you should pass an instance of a type, try

s.set(DoorState::DoorOpened{});

after this change I was able to compile in MSVC 2019 (16.1.3)

Edit: This is an edit to address Scheff and Jarod24 comments, there would have been a case of most vexing parse if we were to uncomment the constructor and write

DoorState s(DoorState::DoorOpened());

This could have been fixed using the uniform initialization syntax, see e.g. https://arne-mertz.de/2015/07/new-c-features-uniform-initialization-and-initializer_list/

DoorState s{DoorState::DoorOpened{}};

This would have solved the most vexing parse issue but created a new issue: DoorState::DoorOpened{}would have been a temporary and it could have never been bound to the input argument of the ctor:

DoorState(State& state)

we then would have needed to change it to

DoorState(const State& state)

Thanks again to Jarod and Scheff for pointing out the issue.

edited Jun 22 '19 at 19:45

answered Jun 22 '19 at 16:16

CuriouslyRecurringThoughts

2,685
2
12
23

@Scheff, I tried both of them but no one works. It is very strange. Only the call of the set "s.set(DoorState::DoorOpened{});" works – getsoubl Jun 22 '19 at 17:42
@getsoubl , which compiler are you using? I tried with MSVC and it works, take a look at https://godbolt.org/z/SjxSt8 for clang and let me know – CuriouslyRecurringThoughts Jun 22 '19 at 17:43
I am using the VS 2017 compiler. The toolset that is used is the Visual Studio 2017 (v141) – getsoubl Jun 22 '19 at 17:53
@getsoubl, I am not Scheff, I think that Scheff got confused with another very similar issue: the most vexing parse. Your issue was NOT a most vexing parse issue, it was simply that you were passing a type instead of an instance of a type – CuriouslyRecurringThoughts Jun 22 '19 at 17:53
1

If OP has fixed the issue in the commented code, OP would have most vexing parse. – Jarod42 Jun 22 '19 at 19:31
@Jarod42 correct, looks like that I misunderstood Scheff all along. I did not even see the commented out part. – CuriouslyRecurringThoughts Jun 22 '19 at 19:38

How to pass a variant as constructor parameter or as function argument

1 Answers1