C++ State Machines and hiding classes in files

Question

I am trying to write some code which to the best of my knoledge is an example of a state machine.

What I have done so far is:

#include <map>
#include <iostream>

class StateInstance
{
    std::string m_string;

public: 

    StateInstance(const std::string& string)
        : m_string{string}
    {
    }
    
    std::string Get() const
    {
        return m_string;
    }
}instance_a("hello world"), instance_b("bring me coffee");

enum class StateInstanceOption
{
    STATE_INSTANCE_A,
    STATE_INSTANCE_B
}gCurrentState{StateInstanceOption::STATE_INSTANCE_A}; // global variable to hold current state "pointer" (really a flag)

class StateInstanceMapper
{
    std::map<StateInstanceOption, const StateInstance&> m_map;
    
public:
    
    StateInstanceMapper()
    {
        m_map.insert(std::pair<StateInstanceOption, const StateInstance&>(StateInstanceOption::STATE_INSTANCE_A, instance_a));
        m_map.insert(std::pair<StateInstanceOption, const StateInstance&>(StateInstanceOption::STATE_INSTANCE_B, instance_b));
    }
    
    const StateInstance& DoMap(/*const StateInstanceOption opt*/) const
    {
        return m_map.at(/*opt*/ gCurrentState);
    }
    
}mapper_instance;

int main()
{

    std::cout << mapper_instance.DoMap(/*gCurrentState*/).Get() << std::endl;

    gCurrentState = StateInstanceOption::STATE_INSTANCE_B;
    
    std::cout << mapper_instance.DoMap(/*gCurrentState*/).Get() << std::endl;
    
    return 0;
}

This works fine, however during the runtime of my program I only want there to exist a single state.

I want a way to prevent the user creating another instance of StateInstance, StateInstanceOption and StateInstanceMapper

For the example of a function, (in C), I would make the function static, and put the function in a seperate header, thus preventing it from being seen in other files.

Is there anything I can do to stop the end user creating more instances of these objects?

Since this question was disruptively closed so rappidly I cannot add an answer as an answer, however here is "the answer to this question"

#include <map>
#include <iostream>

class StateInstance
{
    std::string m_string;

public:

    // somewhat inconveniently, have to create an entirely new function for each possible instance of the state
    static StateInstance& get_instance_a()
    {
        static StateInstance instance_a("hello world");
        return instance_a;
    }
    static StateInstance& get_instance_b()
    {
        static StateInstance instance_b("bring me coffee");
        return instance_b;
    }

private:

    StateInstance(const std::string& string)
        : m_string{string}
    {
    }

    StateInstance(const StateInstance &) = delete;
    StateInstance& operator=(const StateInstance&) = delete;
    
public:

    std::string Get() const
    {
        return m_string;
    }
}; // instance_a("hello world"), instance_b("bring me coffee");

enum class StateInstanceOption
{
    STATE_INSTANCE_A,
    STATE_INSTANCE_B
}gCurrentState{StateInstanceOption::STATE_INSTANCE_A}; // global variable to hold current state "pointer" (really a flag)

class StateInstanceMapper
{
    std::map<StateInstanceOption, const StateInstance&> m_map;
    
public:

    static StateInstanceMapper& getInstance()
    {
        static StateInstanceMapper instance;
        return instance;
    }
    
private:
    
    StateInstanceMapper()
    {
        m_map.insert(std::pair<StateInstanceOption, const StateInstance&>(StateInstanceOption::STATE_INSTANCE_A, StateInstance::get_instance_a()));
        m_map.insert(std::pair<StateInstanceOption, const StateInstance&>(StateInstanceOption::STATE_INSTANCE_B, StateInstance::get_instance_b()));
    }
    
    StateInstanceMapper(const StateInstanceMapper &) = delete;
    StateInstanceMapper& operator=(const StateInstanceMapper &) = delete;
    
public:

    const StateInstance& DoMap(/*const StateInstanceOption opt*/) const
    {
        return m_map.at(/*opt*/ gCurrentState);
    }
    
}; //mapper_instance;

int main()
{

    //std::cout << mapper_instance.DoMap(/*gCurrentState*/).Get() << std::endl;
    std::cout << StateInstanceMapper::getInstance().DoMap().Get() << std::endl;

    gCurrentState = StateInstanceOption::STATE_INSTANCE_B;
    
    //std::cout << mapper_instance.DoMap(/*gCurrentState*/).Get() << std::endl;
    std::cout << StateInstanceMapper::getInstance().DoMap().Get() << std::endl;
    
    return 0;
}

_"Sounds promising"_ - I thought the same thing about sonic diarrhea. — Captain Obvlious, Jun 19 '17 at 20:11
No, no, no. *Please* don't spread the singleton madness. They cause *so* much pain for no gain. They are just glorified global variables, with all the negative things they bring to the table. Tight coupling, uncertain order of construction/destruction, keeping resources alive for too long and so, so much more. Don't go down that path. — Jesper Juhl, Jun 19 '17 at 20:18
@user3728501 To write proper state machines you may be interested in my [STTCL Framework](https://github.com/makulik/sttcl). — πάντα ῥεῖ, Jun 19 '17 at 20:21
@user3728501 For your states you should have a look at the [_Flyweight Pattern_](https://sourcemaking.com/design_patterns/flyweight) (which merely ends up in singleton representation of States, which model the behavioral parts). — πάντα ῥεῖ, Jun 19 '17 at 20:30
Have you considered using `std::variant` for state machine? There are some advantages going that route, including compile-time validation that all of your states are covered. http://khuttun.github.io/2017/02/04/implementing-state-machines-with-std-variant.html — Michaël Roy, Jun 19 '17 at 21:15

Nullrelation · Answer 1 · 2017-06-19T20:17:53.493

-1

What you are trying to create is a singleton, make the constructor private, and provide a function that will provide the singleton instance.

As an example of a singleton in C++:

class Singleton {
  std::string message;

  // Private constructor
  Singleton(const std::string& s) : message(s) {}

public:
  static Singleton& instance() {
    static Singleton s ("Hello!");
    return s;
  }

  const std::string& get_message() {
    return message;
  }
}

edited Jun 19 '17 at 20:17

answered Jun 19 '17 at 20:09

Nullrelation

288
5
13

Wait what's the second part to this? How does it work if the constructor is private? – FreelanceConsultant Jun 19 '17 at 20:10
If the constructor is private, then you can only use the constructor inside the class. The class can provide a static function which will create the instances. – Nullrelation Jun 19 '17 at 20:10
Where do I call the static function from? – FreelanceConsultant Jun 19 '17 at 20:12
Edited my answer with an example – Nullrelation Jun 19 '17 at 20:18
Is it correct to say that I require a unique `instance()` function for each instance that I want, say for example in my example I had 2 possible instances of `class StateInstance`, but only one of the mapper class? – FreelanceConsultant Jun 19 '17 at 20:24
@user3728501 _"for each instance"_ There will be only a single one, that's the whole point. – πάντα ῥεῖ Jun 19 '17 at 20:27
@πάνταῥεῖ Not quite true, if you see my example you will understand why. – FreelanceConsultant Jun 19 '17 at 20:29
@πάνταῥεῖ I feel like you probably didn't read this question properly before whacking the CLOSE THIS QUESTION button. – FreelanceConsultant Jun 19 '17 at 20:29
@user3728501 I know quite well what you (and I am) talking about. Just read the linked material. – πάντα ῥεῖ Jun 19 '17 at 20:31
@πάνταῥεῖ Without wanting to start a pointless argument here, that clearly isn't the case if you didn't understand my point about multiple instances. Note that one class has 2 instances, and another class which is a so called singleton does only have a single instance,. – FreelanceConsultant Jun 19 '17 at 20:34
@user3728501 Did you even bother to read about the [_State_](https://sourcemaking.com/design_patterns/state) design pattern? – πάντα ῥεῖ Jun 19 '17 at 20:36
@user3728501 Probably depends on your POV how to design such stuff. Well, I'll reopen the question. IMO you're barking up the wrong tree and your design is currently flawed. – πάντα ῥεῖ Jun 19 '17 at 20:38
@user3728501 closing your question as a duplicate is applicable because it solved your problem (not directly, but with only minor modifications). – kmdreko Jun 19 '17 at 20:39
@Nullrelation Singletons are going out of favor very rapidly for very good reasons. One thing that is gaining momentum quite fast is using std::variant / visitor concept to implement state machines. – Michaël Roy Jun 19 '17 at 21:08

C++ State Machines and hiding classes in files

Since this question was disruptively closed so rappidly I cannot add an answer as an answer, however here is "the answer to this question"

1 Answers1