template + lambda의 편리함

#include <string>
 
class Application {
public:
	Application() {}
	void setTitle(const std::string &title) {
		m_title = title;
		updateWindowTitle();
	}
	void setCount(int count) {
		m_count = count;
	}
	void updateWindowTitle();
private:
	std::string m_title;
	int m_count = 0;
};

#include <string>
#include <vector>
 
class UndoCommand {
public:
	UndoCommand() {}
	virtual ~UndoCommand() {}
	virtual void undo() = 0;
	virtual void redo() = 0;
};
 
class TitleCommand : public UndoCommand {
public:
	TitleCommand(std::string *title, const std::string &to, Application *app)
	: m_title(title), m_to(to), m_from(*title), m_app(app) {}
	virtual void undo() override { *m_title = m_from; m_app->updateWindowTitle(); }
	virtual void redo() override { *m_title = m_to; m_app->updateWindowTitle(); }
private:
	std::string *m_title, m_to, m_from;
	Application *m_app;
};
 
class CountCommand : public UndoCommand {
public:
	CountCommand(int *count, int to)
	: m_count(count), m_to(to), m_from(*count) {}
	virtual void undo() override { *m_count = m_from; }
	virtual void redo() override { *m_count = m_to; }
private:
	int *m_count, m_to, m_from;
};
 
class Application {
public:
	Application() {}
	~Application() {
		for (auto cmd : m_cmds)
			delete cmd;
	}
	void setTitle(const std::string &title) {
		push(new TitleCommand(&m_title, title));
	}
	void setCount(int count) {
		push(new CountCommand(&m_count, count));
	}
	void undo() {
		if (!m_cmds.empty() && m_undone != m_cmds.begin())
			(*--m_undone)->undo();
	}
	void redo() {
		if (m_undone != m_cmds.end())
			(*m_undone++)->redo();
	}
	void updateWindowTitle();
private:
	// 새 명령을 추가
	void push(UndoCommand *cmd) {
		cmd->redo(); // 일단 명령 실행해주고
		m_cmds.erase(m_undone, m_cmds.end()); // 마지막으로 undo/redo 한 거 이후로 다 지우고
		m_cmds.push_back(cmd); // 명령 추가해주고
		m_undone = m_cmds.end(); // 마지막 undo 위치 갱신
	}
	std::string m_title;
	int m_count = 0;
	std::vector<UndoCommand*> m_cmds;
	std::vector<UndoCommand*>::iterator m_undone = m_cmds.end(); // 마지막으로 undo된 위치
};

template<typename T, typename Setter>
class ValueCommand : public UndoCommand {
public:
	ValueCommand(const T &to, const T &from, const Setter &setter)
	: m_to(to), m_from(from), set(setter) {}
	virtual void undo() override { set(m_from); }
	virtual void redo() override { set(m_to); }
private:
	T m_to, m_from; Setter set;
};
 
class Application {
...
	void setTitle(const std::string &title) {
		push(m_title, title, [this] (const std::string &v) {
			m_title = v;
			updateWindowTitle();
		});
	}
	void setCount(int count) {
		push(m_count, count, [this] (int v) {
			m_count = v;
		});
	}
...
private:
	template<typename T, typename Setter>
	void push(const T &to, const T &from, const Setter &setter) {
		push(new ValueCommand<T, Setter>(to, from, setter));
	}
...
};