redefine method for every instance - c++

Question

class man {
public:
void do_something();
}
int main(){
man Joe, Peter, Steve;
Joe.do_something();
Peter.do_something();
Steve.do_something();
return 0;
}
There is only one unique man called Joe. Same with Peter and Steve. And there is something unique about what they do. I may spawn hundreds of instances of man and I need to redefine do_something() function for each of them.
Two attempts I do not like:
1) Joe as a singleton class, that inherits from man.
2) passing a function pointer to do_something().
I want to redefine do_something() function for each instance of man. Is it possible?

Answer 1

The simplest thing to do is pass the action as a parameter to the constructor.
You could use a std::function or a lambda.
Or create another "action" class.
class Action
{
public:
virtual ~Action();
virtual void something() = 0;
};
If you inherit from this for the specifics of what you want, then each man can use the action in the do_something method.

Answer 2

A simple way is to use std::function to customize the behavior:
#include <iostream>
#include <functional>
class man {
public:
std::function<void()> something;
void do_something() { something(); }
}
int main(){
man Joe, Peter, Steve;
Joe.something = [] () { std::cout << "Joe something."; };
Joe.do_something();
Peter.something = [] () { std::cout << "Peter something."; };
Peter.do_something();
Steve.something = [] () { std::cout << "Steve something."; };
Steve.do_something();
return 0;
}
If you want more functionality I suggest having an abstract class that's added to the man class that requires overriding do_something(). Then inheriting from that class for each different action.

Answer 3

Yes. Look at the strategy design pattern:
https://en.wikipedia.org/wiki/Strategy_pattern
#include <memory>
#include <string>
#include <iostream>
class man {
public:
man (std::string const& name) : name_(name) {}
virtual void do_something() {
std::cout << name_ << " does it" << std::endl;
};
protected:
std::string name_;
};
class Joe : public man{
public:
Joe() : man("Joe") {}
};
class Fred : public man {
public:
Fred() : man("Fred") {}
virtual void do_something() override final {
man::do_something();
std::cout << " ... but Fred can do way more" << std::endl;
}
};
class ConcreteMan {
public:
ConcreteMan(std::string const& name) : man_(nullptr) {
if (name == "Joe")
man_.reset(new Joe());
else if (name == "Fred")
man_.reset(new Fred());
else
std::cerr << "No such man " << name << std::endl;
}
void do_something() {
if (man_ != nullptr)
man_->do_something();
else
std::cerr << "No real man" << std::endl;
}
private:
std::unique_ptr<man> man_;
};
int main() {
ConcreteMan joe("Joe"), fred("Fred"), donald("Donald");
joe.do_something();
fred.do_something();
donald.do_something();
return 0;
}

Answer 4

Solution 1: Tag dispatching
You can just add a type and write the behaviour.
struct Joe{ void do(){std::cout << "drink";} };
struct Peter{ void do(){std::cout << "smoke";} };
struct Steve{ void do(){std::cout << "sleep";} };
class man {
public:
template<typename T>
void do_something(){ T.do();}
}
since you have to call do_something() every time, you can consider saving the struct inside the man class, so you can rid of template:
struct man_detail{}
struct Joe : public man_detail{ void do(){std::cout << "drink";} };
struct Peter : public man_detail{ void do(){std::cout << "smoke";} };
struct Steve : public man_detail{ void do(){std::cout << "sleep";} };
class man{
public:
man(man_detail md) : maninfo(md){}
void do_something() { maninfo.do(); }
private:
man_detail maninfo;
};
in any time your man_detail can evolve to an interface and add more methods.
Solution 2: Template specialization
your man class become a template, so man and man are to completely different types you can just provides a partial specialization.
struct Joe{};
struct Peter{};
struct Steve{};
template <typename T>
class man
{
void do_something() {}
}
template <Joe> void man::do_something(){std::cout << "drink";}
template <Peter> void man::do_something(){std::cout << "smoke";}
template <> void man::do_something(){std::cout << "sleep";}