1 命令模式的基本概念

C++ 命令模式是一種設(shè)計模式，它允許將請求封裝為一個對象，從而可以用不同的請求對客戶進行參數(shù)化；對請求排隊或記錄請求日志，以及支持可撤銷的操作。命令模式的主要目的是將請求封裝為對象，從而可以使用不同的請求把客戶端與接收者解耦。

在命令模式中，通常包含以下幾個關(guān)鍵角色：

（1）命令（Command）： 這是一個抽象類，它聲明了執(zhí)行操作的接口。具體的命令類會實現(xiàn)這個接口，并綁定到一個接收者對象上。當命令對象被調(diào)用時，它會調(diào)用接收者的相應(yīng)操作。

（2）具體命令（ConcreteCommand）： 這是命令接口的具體實現(xiàn)類，它持有一個接收者對象，并實現(xiàn)了命令接口中的執(zhí)行方法。當執(zhí)行方法被調(diào)用時，它會調(diào)用接收者的相應(yīng)方法來完成請求的操作。

（3）請求者（Invoker）： 請求者負責調(diào)用命令對象的執(zhí)行方法。它不需要知道具體的命令對象類型，只需要知道它是一個命令對象即可。

（4）接收者（Receiver）： 接收者對象知道如何執(zhí)行請求的操作。它具體實現(xiàn)了請求的功能。

2 命令模式的實現(xiàn)步驟

命令模式的實現(xiàn)步驟如下：

（1）定義命令接口：

• 創(chuàng)建一個抽象類（或接口），聲明一個執(zhí)行操作的方法。這個方法將是所有具體命令類共有的接口。

（2）實現(xiàn)具體命令類：

• 創(chuàng)建具體命令類，繼承自命令接口。
• 在具體命令類中，通常包含一個指向接收者對象的指針（或引用）。
• 實現(xiàn)執(zhí)行操作的方法，該方法內(nèi)部調(diào)用接收者對象的相應(yīng)方法來完成請求的操作。

（3）創(chuàng)建接收者類：

• 定義一個接收者類，它包含實際執(zhí)行操作的邏輯。
• 接收者類的方法對應(yīng)于命令類需要執(zhí)行的操作。

（4）創(chuàng)建請求者類：

• 請求者類負責調(diào)用命令對象的執(zhí)行方法。
• 請求者不需要知道具體的命令對象類型，它只需要持有一個命令對象的指針（或引用）。
• 請求者類可以存儲多個命令對象，并按照需要調(diào)用它們的執(zhí)行方法。

（5）將命令對象與接收者對象關(guān)聯(lián)：

• 在創(chuàng)建具體命令對象時，將接收者對象傳遞給命令對象，以便命令對象在執(zhí)行時可以調(diào)用接收者的方法。

（6）使用命令模式：

• 在客戶端代碼中，創(chuàng)建接收者對象。
• 創(chuàng)建與接收者對象關(guān)聯(lián)的具體命令對象。
• 將命令對象傳遞給請求者對象。
• 請求者對象調(diào)用命令對象的執(zhí)行方法，從而間接調(diào)用接收者的方法，完成請求的操作。

如下為樣例代碼：

#include <iostream>  
#include <memory>  
#include <string>  
#include <vector>  

// 創(chuàng)建接收者類  
class Receiver {
public:
	void action() {
		std::cout << "Receiver::action() called" << std::endl;
	}
};

// 定義命令接口  
class Command {
public:
	virtual ~Command() = default;
	virtual void execute() = 0;
};

// 實現(xiàn)具體命令類  
class ConcreteCommand : public Command {
public:
	ConcreteCommand(std::shared_ptr<Receiver> receiver) : m_receiver(receiver) {}
	void execute() override {
		m_receiver->action();
	}
private:
	std::shared_ptr<Receiver> m_receiver;
};

// 創(chuàng)建請求者類  
class Invoker {
public:
	void setCommand(std::unique_ptr<Command> command) {
		commands.push_back(std::move(command));
	}

	void executeCommands() {
		for (auto& cmd : commands) {
			cmd->execute();
		}
	}

private:
	std::vector<std::unique_ptr<Command>> commands;
};

// 客戶端代碼  
int main() 
{
	// 創(chuàng)建接收者對象  
	std::shared_ptr<Receiver> receiver = std::make_shared<Receiver>();

	// 創(chuàng)建具體命令對象，并與接收者對象關(guān)聯(lián)  
	std::unique_ptr<Command> command = std::make_unique<ConcreteCommand>(receiver);

	// 創(chuàng)建請求者對象，并將命令對象傳遞給請求者  
	Invoker invoker;
	invoker.setCommand(std::move(command));

	// 請求者調(diào)用命令對象的執(zhí)行方法  
	invoker.executeCommands(); // 輸出: Receiver::action() called  

	return 0;
}

上面代碼的輸出為：

Receiver::action() called

在這個示例中：

• Command 是一個抽象類，定義了命令的接口。
• ConcreteCommand 是 Command 的具體實現(xiàn)，它持有一個指向 Receiver 的 shared_ptr，并在 execute 方法中調(diào)用 Receiver 的 action 方法。
• Receiver 是接收者類，包含了實際要執(zhí)行的操作。
• Invoker 是請求者類，它持有一個 Command 對象的列表，并提供了一個方法來執(zhí)行這些命令。

在 main 函數(shù)中，創(chuàng)建了 Receiver 對象和 ConcreteCommand 對象，并將 Receiver 對象傳遞給 ConcreteCommand 對象。然后將 ConcreteCommand 對象傳遞給 Invoker 對象，并調(diào)用 Invoker 的 executeCommands 方法來執(zhí)行命令。最終，Receiver 的 action 方法被調(diào)用，輸出了相應(yīng)的信息。

3 命令模式的應(yīng)用場景

C++命令模式的應(yīng)用場景廣泛，主要適用于以下情況：

（1）當功能需要支持撤銷和恢復(fù)撤銷操作時： 命令模式通過封裝命令對象，可以方便地記錄和執(zhí)行命令歷史，從而支持撤銷和恢復(fù)撤銷操作。這在圖形編輯、文本編輯等應(yīng)用中非常有用，例如，在繪制圖形時，用戶可以撤銷最近的操作以返回到之前的狀態(tài)。

（2）當需要設(shè)計一組命令，并且命令之間可以相互組合時： 命令模式支持將多個命令組合成一個復(fù)合命令，從而可以一次性執(zhí)行多個操作。這在需要執(zhí)行一系列相關(guān)操作時非常有用，例如，在編輯器中，用戶可能希望將多個編輯操作（如剪切、復(fù)制、粘貼）組合成一個宏命令，以便一次性執(zhí)行。

（3）當系統(tǒng)需要將命令發(fā)起者和命令執(zhí)行者解耦時： 命令模式允許將請求封裝為命令對象，從而使發(fā)送請求的對象和執(zhí)行請求的對象解耦。這使得發(fā)送請求的對象不需要知道請求如何被完成，增加了系統(tǒng)的靈活性和可維護性。例如，在用戶界面和后臺邏輯之間，命令模式可以確保它們之間的松耦合，使得修改其中一方不會影響到另一方。

（4）當系統(tǒng)需要在不同時間指定、排列和執(zhí)行請求時： 命令模式允許將命令對象存儲在隊列或列表中，然后根據(jù)需要按順序執(zhí)行它們。這對于實現(xiàn)批量操作、延遲執(zhí)行或任務(wù)調(diào)度等功能非常有用。

總的來說，C++命令模式適用于需要解耦請求發(fā)送者和請求執(zhí)行者、支持撤銷操作、需要組合多個命令或在不同時間執(zhí)行請求的場景。它能夠提高系統(tǒng)的靈活性、可維護性和可擴展性。

3.1 命令模式應(yīng)用于需要支持撤銷和恢復(fù)撤銷操作的場景

在 C++ 中，命令模式特別適用于需要支持撤銷和恢復(fù)撤銷操作的場景，如下為樣例代碼：

#include <iostream>  
#include <memory>  
#include <vector>  
#include <stack>  
#include <string>  

// 接收者類  
class Receiver {
public:
	std::string action() {
		std::string currentState = "New state"; // 假設(shè)這是某種狀態(tài)  
		// 執(zhí)行一些操作...  
		return currentState;
	}

	void restore(const std::string& state) {
		// 恢復(fù)到之前的狀態(tài)...  
		std::cout << "Restoring to state: " << state << std::endl;
	}
};

// 命令接口  
class Command {
public:
	virtual ~Command() = default;
	virtual void execute() = 0;
	virtual void undo() = 0;
};

// 具體命令類  
class ConcreteCommand : public Command {
public:
	ConcreteCommand(std::shared_ptr<Receiver> receiver) : receiver(receiver) {}

	void execute() override {
		previousState = receiver->action();
		std::cout << "Command executed: " << previousState << std::endl;
	}

	void undo() override {
		receiver->restore(previousState);
		std::cout << "Command undone: " << previousState << std::endl;
	}

private:
	std::shared_ptr<Receiver> receiver;
	std::string previousState;
};

// 撤銷管理器  
class UndoManager {
public:
	void executeCommand(std::shared_ptr<Command> cmd) {
		cmd->execute();
		commands.push(cmd);
	}

	void undoLastCommand() {
		if (!commands.empty()) {
			auto cmd = commands.top();
			commands.pop();
			cmd->undo();
		}
		else {
			std::cout << "No commands to undo." << std::endl;
		}
	}

private:
	std::stack<std::shared_ptr<Command>> commands;
};

int main() 
{
	// 創(chuàng)建接收者對象  
	auto receiver = std::make_shared<Receiver>();

	// 創(chuàng)建命令對象  
	auto command = std::make_shared<ConcreteCommand>(receiver);

	// 創(chuàng)建撤銷管理器  
	UndoManager undoManager;

	// 執(zhí)行命令  
	undoManager.executeCommand(command);

	// 撤銷命令  
	undoManager.undoLastCommand();

	return 0;
}

上面代碼的輸出為：

Command executed: New state
Restoring to state: New state
Command undone: New state

在這個示例中：

• Command 是一個抽象類，定義了命令的接口，包括 execute 和 undo 方法。
• ConcreteCommand 是 Command 的具體實現(xiàn)，它持有一個指向 Receiver 的 shared_ptr，并在 execute 方法中執(zhí)行操作，同時保存當前狀態(tài)以便在 undo 方法中恢復(fù)。
• Receiver 類包含實際執(zhí)行操作的邏輯，以及一個 restore 方法用于恢復(fù)之前的狀態(tài)。
• UndoManager 類負責管理命令的撤銷操作，它使用一個 stack 來存儲執(zhí)行過的命令對象。當調(diào)用 executeCommand 方法時，它會執(zhí)行命令并將其推入棧中；當調(diào)用 undoLastCommand 方法時，它會從棧頂彈出命令并執(zhí)行其 undo 方法。

在 main 函數(shù)中，創(chuàng)建了一個 Receiver 對象和一個 ConcreteCommand 對象，并通過 UndoManager 來執(zhí)行和撤銷命令。通過使用 shared_ptr，可以確保 Receiver 和 ConcreteCommand 對象的生命周期得到妥善管理，即使在命令被撤銷后也不會導(dǎo)致內(nèi)存泄漏。

3.2 命令模式應(yīng)用需要設(shè)計一組命令，并且命令之間可以相互組合的場景

在C++中，命令模式可以用于設(shè)計一組命令，并允許這些命令之間可以相互組合，形成復(fù)合命令。當需要執(zhí)行一系列操作作為一個單一命令時，這種模式特別有用。如下為樣例代碼：

#include <iostream>  
#include <memory>  
#include <vector>  

// 命令接口  
class Command {
public:
	virtual ~Command() = default;
	virtual void execute() = 0;
};

// 具體命令類A  
class CommandA : public Command {
public:
	void execute() override {
		std::cout << "Executing CommandA" << std::endl;
	}
};

// 具體命令類B  
class CommandB : public Command {
public:
	void execute() override {
		std::cout << "Executing CommandB" << std::endl;
	}
};

// 復(fù)合命令類  
class CompositeCommand : public Command {
public:
	void addCommand(std::shared_ptr<Command> cmd) {
		commands.push_back(cmd);
	}

	void execute() override {
		for (const auto& cmd : commands) {
			cmd->execute();
		}
	}

private:
	std::vector<std::shared_ptr<Command>> commands;
};

int main() 
{
	// 創(chuàng)建具體命令對象  
	auto cmdA = std::make_shared<CommandA>();
	auto cmdB = std::make_shared<CommandB>();

	// 創(chuàng)建復(fù)合命令對象  
	auto compositeCmd = std::make_shared<CompositeCommand>();

	// 將具體命令添加到復(fù)合命令中  
	compositeCmd->addCommand(cmdA);
	compositeCmd->addCommand(cmdB);

	// 執(zhí)行復(fù)合命令  
	compositeCmd->execute();

	return 0;
}

上面代碼的輸出為：

Executing CommandA
Executing CommandB

在這個示例中：

• Command 是一個抽象基類，定義了命令的接口，即 execute 方法。
• CommandA 和 CommandB 是具體命令類，分別實現(xiàn)了 execute 方法以執(zhí)行特定的操作。
• CompositeCommand 是一個復(fù)合命令類，它包含一個命令對象的 vector 容器。通過 addCommand 方法，可以將多個具體命令或復(fù)合命令添加到復(fù)合命令中。當調(diào)用 execute 方法時，它會依次執(zhí)行容器中的每個命令。

在 main 函數(shù)中，創(chuàng)建了兩個具體命令對象 cmdA 和 cmdB，然后創(chuàng)建了一個復(fù)合命令對象 compositeCmd。接著，將 cmdA 和 cmdB 添加到 compositeCmd 中。最后，調(diào)用 compositeCmd 的 execute 方法來執(zhí)行復(fù)合命令，這將依次執(zhí)行 cmdA 和 cmdB。

4 命令模式的優(yōu)點與缺點

C++ 命令模式的優(yōu)點主要包括：

（1）封裝性： 每個命令都被封裝起來，客戶端無需知道命令具體是怎么執(zhí)行的，只需調(diào)用相應(yīng)的命令。這使得命令模式能夠很好地隱藏實現(xiàn)細節(jié)，使系統(tǒng)更加模塊化和可維護。

（2）擴展性： 命令模式符合開閉原則，即對擴展開放，對修改關(guān)閉。這意味著可以輕松地添加新命令而無需修改現(xiàn)有代碼。

（3）支持撤銷和重做： 命令模式可以方便地實現(xiàn)對請求的撤銷和重做，這對于需要支持撤銷操作的系統(tǒng)來說非常有用。

（4）請求排隊和記錄： 命令模式可以較容易地設(shè)計一個命令隊列，以及在需要的情況下將命令記入日志。

（5）解耦： 命令模式將請求一個操作的對象與知道如何執(zhí)行一個操作的對象分隔開，降低了系統(tǒng)的耦合度。

然而，C++ 命令模式也存在一些缺點：

（1）可能產(chǎn)生過多的具體命令類： 對于每一個命令，都需要設(shè)計一個具體命令類，這可能導(dǎo)致系統(tǒng)中存在大量的具體命令類，增加了系統(tǒng)的復(fù)雜性。

（2）可能導(dǎo)致過度設(shè)計： 在一些簡單的場景下，使用命令模式可能過于復(fù)雜，導(dǎo)致過度設(shè)計，增加不必要的開銷。文章來源地址http://www.zghlxwxcb.cn/news/detail-840882.html

到了這里，關(guān)于突破編程_C++_設(shè)計模式（命令模式）的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！