代替switch的设计模式
Open sidebar
代替switch的设计模式
Model: Default
代替switch的设计模式是哪个，用c++实现
代替 switch 语句的一种设计模式是策略模式（Strategy Pattern）。策略模式是一种对象行为模式，它定义了一系列算法，将每个算法封装起来，并使它们可以相互替换。这种模式让算法的变化独立于使用它的客户端。
以下是使用 C++ 实现策略模式的示例代码：
c++Copy code#include <iostream>
#include <string>
#include <memory>
class Strategy {
public:
virtual void execute() = 0;
};
class StrategyA : public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy A" << std::endl;
}
};
class StrategyB : public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy B" << std::endl;
}
};
class Context {
private:
std::unique_ptr<Strategy> strategy_;
public:
void set_strategy(std::unique_ptr<Strategy> strategy) {
strategy_ = std::move(strategy);
}
void execute_strategy() {
strategy_->execute();
}
};
int main() {
Context context;
// 使用策略 A
context.set_strategy(std::make_unique<StrategyA>());
context.execute_strategy();
// 使用策略 B
context.set_strategy(std::make_unique<StrategyB>());
context.execute_strategy();
return 0;
}
在这个示例中，Strategy 是一个抽象类，定义了算法执行的接口。StrategyA 和 StrategyB 是两种具体的算法，实现了 Strategy 的接口。Context 类则是使用策略的客户端，它可以设置不同的策略，并执行它们。通过使用策略模式，我们可以避免使用 switch 语句来选择不同的算法，从而实现更加灵活和可扩展的代码。
在main函数里分别计算 context.execute_strategy()运行时间
要计算 context.execute_strategy() 运行的时间，可以使用 C++ 标准库中的 chrono 头文件。下面是示例代码：
c++Copy code#include <iostream>
#include <string>
#include <memory>
#include <chrono>
class Strategy {
public:
virtual void execute() = 0;
};
class StrategyA : public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy A" << std::endl;
}
};
class StrategyB : public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy B" << std::endl;
}
};
class Context {
private:
std::unique_ptr<Strategy> strategy_;
public:
void set_strategy(std::unique_ptr<Strategy> strategy) {
strategy_ = std::move(strategy);
}
void execute_strategy() {
strategy_->execute();
}
};
int main() {
Context context;
// 使用策略 A 并计算运行时间
context.set_strategy(std::make_unique<StrategyA>());
auto start_time = std::chrono::high_resolution_clock::now();
context.execute_strategy();
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count();
std::cout << "Execution time for Strategy A: " << duration << " microseconds" << std::endl;
// 使用策略 B 并计算运行时间
context.set_strategy(std::make_unique<StrategyB>());
start_time = std::chrono::high_resolution_clock::now();
context.execute_strategy();
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count();
std::cout << "Execution time for Strategy B: " << duration << " microseconds" << std::endl;
return 0;
}
在这个示例中，我们使用 std::chrono::high_resolution_clock 来获取当前时间，并计算 context.execute_strategy() 运行的时间。注意，我们使用 std::chrono::duration_cast<std::chrono::microseconds> 将时间差转换为微秒，以便更好地衡量运行时间。最后，我们输出了每个策略的运行时间。
用一个函数，参数化 context.execute_strategy() 实现统计运行时间
你可以将计算运行时间的代码封装在一个函数中，将 context.execute_strategy() 作为参数，从而实现参数化的运行时间统计。
以下是示例代码：
c++Copy code#include <iostream>
#include <string>
#include <memory>
#include <chrono>
#include <functional>
class Strategy {
public:
virtual void execute() = 0;
};
class StrategyA : public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy A" << std::endl;
}
};
class StrategyB : public Strategy {
public:
void execute() override {
std::cout << "Executing Strategy B" << std::endl;
}
};
class Context {
private:
std::unique_ptr<Strategy> strategy_;
public:
void set_strategy(std::unique_ptr<Strategy> strategy) {
strategy_ = std::move(strategy);
}
void execute_strategy() {
strategy_->execute();
}
};
template<typename Func>
void measure_execution_time(Func f) {
auto start_time = std::chrono::high_resolution_clock::now();
f();
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time).count();
std::cout << "Execution time: " << duration << " microseconds" << std::endl;
}
int main() {
Context context;
// 使用策略 A 并计算运行时间
context.set_strategy(std::make_unique<StrategyA>());
measure_execution_time([&context](){ context.execute_strategy(); });
// 使用策略 B 并计算运行时间
context.set_strategy(std::make_unique<StrategyB>());
measure_execution_time([&context](){ context.execute_strategy(); });
return 0;
}
在这个示例中，我们定义了一个 measure_execution_time 函数，它接受一个函数对象（即可调用对象），并计算该函数对象的运行时间。在 main 函数中，我们使用 lambda 表达式来创建函数对象，该函数对象调用 context.execute_strategy() 方法。然后，我们将这个函数对象传递给 measure_execution_time 函数，并计算运行时间。注意，我们使用 [](){} 来定义 lambda 表达式，其中 &context 表示通过引用捕获 context 对象，以便在 lambda 表达式中使用它。
Strategy里是实现chatgpt api的获取
Strategy 模式是一种用于解决算法选择问题的设计模式，它将不同的算法封装在不同的策略类中，并允许客户端动态地选择使用哪种策略。
对于 ChatGPT API 的获取，我们可以使用 Strategy 模式来实现。假设我们有两种获取 API 的策略：一种是使用 HTTP GET 请求，另一种是使用 WebSocket 连接。我们可以将这两种策略分别封装在 HttpStrategy 和 WebSocketStrategy 类中，然后让客户端根据需要动态地选择使用哪种策略。
以下是示例代码：
c++Copy code#include <iostream>
#include <string>
#include <memory>
class ApiStrategy {
public:
virtual std::string get_api() = 0;
};
class HttpStrategy : public ApiStrategy {
public:
std::string get_api() override {
// 使用 HTTP GET 请求获取 API
return "https://api.example.com/chatgpt";
}
};
class WebSocketStrategy : public ApiStrategy {
public:
std::string get_api() override {
// 使用 WebSocket 连接获取 API
return "wss://api.example.com/chatgpt";
}
};
class Chatbot {
private:
std::unique_ptr<ApiStrategy> api_strategy_;
public:
void set_api_strategy(std::unique_ptr<ApiStrategy> api_strategy) {
api_strategy_ = std::move(api_strategy);
}
void get_response(std::string input) {
std::string api = api_strategy_->get_api();
// 使用指定的 API 进行请求并获取响应
std::cout << "Getting response from API: " << api << std::endl;
// ...
}
};
int main() {
Chatbot chatbot;
// 使用 HTTP GET 请求获取 API
chatbot.set_api_strategy(std::make_unique<HttpStrategy>());
chatbot.get_response("Hello");
// 使用 WebSocket 连接获取 API
chatbot.set_api_strategy(std::make_unique<WebSocketStrategy>());
chatbot.get_response("Hi");
return 0;
}
在这个示例中，ApiStrategy 是一个抽象类，定义了获取 API 的接口。HttpStrategy 和 WebSocketStrategy 是两种具体的获取 API 的策略，实现了 ApiStrategy 的接口。Chatbot 类是使用 API 的客户端，它可以设置不同的 API 获取策略，并使用指定的 API 进行请求和获取响应。
在 main 函数中，我们分别使用 HttpStrategy 和 WebSocketStrategy 来获取 API，并使用 Chatbot 对象来进行请求和获取响应。这样，我们就可以通过动态地选择不同的获取 API 策略，来实现灵活的 API 获取方案。
New chat