How to interact with the strategy design patten - c++

Question

I would like to ask a couple of questions of design patterns.
Lets take for example strategy design pattern:
class Printer{
public:
void print(Message){
}
};
class Message{
public:
void print();
};
class SingleMessage : public Message{
string s;
public:
void print();
};
class Messages : public Message{
vector<Message> v;
public:
void print();
};
According to UML of this pattern, Printer should have method print(Message). What I don't understand (and sorry if this is idiotic question) is do we need to call Message class print method or what? We need to print out message, but we can't create new Message object in class Printer, because then it would be composition. So what should we do then?
Also, maybe you can share some sort of tutorial in which design patterns would be explained (how to use them, when to use them, etc.)?

Answer 1

First off, the concept of composition is on a whole different level than design patterns. Most design patterns use composition – that’s totally fine.
Secondly, no, you don’t use composition here. You invoke the print function of the argument that’s passed to the printer:
class Printer{
public:
void print(Message& m) {
m.print();
}
};
I’ve gone ahead and fixed a bug: the argument needs to be passed by reference (or as a pointer), otherwise you lose the dynamic type. For that reason, the Message::print function also needs to be declared as virtual.

Answer 2

What I don't understand (and sorry if this is idiotic question) is do we need to call Message class print method or what?
Yes. The Message::print function should be abstract, and implemented (as a different strategy) in each class inheriting from Message.
We need to print out message, but we can't create new Message object in class Printer, because then it would be composition. So what should we do then?
You don't need to create a new instance in the printer (i.e. you don't need composition here). All you do here is choose the implementation strategy for printing by deciding what concrete implementation will be passed into the Printer::print function.
Also, maybe you can share some sort of tutorial in which design patterns would be explained (how to use them, when to use them, etc.)?
Normally design patterns are idiomatic solutions to re-occurring design problems. You can find details on wikipedia regarding when to use them. For example, this page says:
"In computer programming, the strategy pattern (also known as the
policy pattern) is a software design pattern, whereby an algorithm's
behaviour can be selected at runtime."
As a side note, this is not a very good example for the strategy pattern. A better one would have been to abstract what printing means, not what a message means:
class Message{
public:
void display(Printer& p) {
p.print(*this); // what printing strategy is applied to
// display the message depends on the
// concrete type of the parameter (on what
// Printer specialization you call
// the function with)
}
};
struct Printer{
virtual void print(Message& m);
};
struct BWPrinter: Printer {
virtual void print(Message& m);
};
struct ColorPrinter: Printer {
virtual void print(Message& m);
};
struct IOStreamPrinter: Printer {
IOStreamPrinter(std::iostream& s);
virtual void print(Message& m);
};

Answer 3

What you probably want to do is to provide a Printer as Strategy. You can spezialize a CoutPrinter FilePrinter or PrinterPrinter...
class Printer{
public:
virtual void print(const string& message) = 0;
};
class CoutPrinter{
public:
void print(const string& message) override {
std::cout << message << "\n";
}
};
You can then use this concept to print messages:
class Message{
public:
virtual print(Printer& printer) = 0;
};
class SingleMessage : public Message {
string s;
public:
void print(Printer& printer) override
{
printer.print(s)
}
};
class Messages {
vector<Message> messages;
std::unique_ptr<Printer> printer;
public:
/// Inject the concrete Printer strategy here
Messages(std::unique_ptr<Printer> printerStrategy) :
printer(move(printer))
{}
void print() {
for(auto& m : messages)
m.print(*printer);
}
};
You can know use constructor injection to select different printers for your Messages
int main()
{
Messages messages {std::make_unique<CoutPrinter>()};
messages.print(); // will print all messages to std::cout
}
Composite Pattern
In your example you derived Messages from Message. This is the Composite Pattern. You can combine both:
class Messages : public Messages {
vector<Message> messages;
public:
void print(Printer& printer) override {
for(auto& m : messages)
m.print(*printer);
}
};
int main()
{
Messages messages;
CoutPrinter printer;
messages.print(printer); // will print all messages to std::cout
}