A+B problem 太简单了哈哈！
2025-10-27 18:08:48
发布于：上海
9阅读
0回复
0点赞
注意看，眼前这道题：
代码（C++20）:
大家觉不觉得很眼熟？
想不想把代码编程长些？？
他来了！！！
哈哈哈
#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <functional>
#include <thread>
#include <mutex>
#include <future>
#include <chrono>
#include <sstream>
#include <stdexcept>
#include <type_traits>
#include <numeric>
#include <algorithm>
#include <map>
#include <set>
#include <tuple>
#include <any>
#include <variant>
#include <optional>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <cstdlib>
#include <cstdint>
#include <cmath>
#include <random>
#include <condition_variable>
#include <atomic>
#include <shared_mutex>
#include <latch>
#include <barrier>
#include <semaphore>
#include <pthread.h>
#include <dlfcn.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <nlohmann/json.hpp>
namespace fs = std::filesystem;
using json = nlohmann::json;
using namespace std::chrono_literals;
// 元编程基础组件
template <typename... Ts> struct TypeList {};
template <typename T> struct TypeListSize;
template <typename... Ts> struct TypeListSize<TypeList<Ts...>> : std::integral_constant<size_t, sizeof...(Ts)> {};
template <typename T, typename List> struct TypeIndex;
template <typename T, typename... Ts>
struct TypeIndex<T, TypeList<T, Ts...>> : std::integral_constant<size_t, 0> {};
template <typename T, typename U, typename... Ts>
struct TypeIndex<T, TypeList<U, Ts...>> : std::integral_constant<size_t, 1 + TypeIndex<T, TypeList<Ts...>>::value> {};
// 日志系统（单例+策略模式）
namespace Logger {
enum class Level { TRACE, DEBUG, INFO, WARN, ERROR, FATAL };
class LogSink {
public:
virtual ~LogSink() = default;
virtual void log(Level level, const std::string& msg) = 0;
};
class ConsoleSink : public LogSink {
public:
void log(Level level, const std::string& msg) override {
std::lock_guard<std::mutex> lock(mtx_);
std::cout << "[" << levelToString(level) << "] " << msg << std::endl;
}
private:
std::mutex mtx_;
std::string levelToString(Level level) {
switch(level) {
case Level::TRACE: return "TRACE";
case Level::DEBUG: return "DEBUG";
case Level::INFO: return "INFO";
case Level::WARN: return "WARN";
case Level::ERROR: return "ERROR";
case Level::FATAL: return "FATAL";
default: return "UNKNOWN";
}
}
};
class FileSink : public LogSink {
public:
FileSink(const std::string& path) {
fs::create_directories(fs::path(path).parent_path());
file_.open(path, std::ios::app);
if (!file_.is_open()) {
throw std::runtime_error("无法打开日志文件: " + path);
}
}
void log(Level level, const std::string& msg) override {
std::lock_guard<std::mutex> lock(mtx_);
auto now = std::chrono::system_clock::now();
std::time_t now_time = std::chrono::system_clock::to_time_t(now);
file_ << "[" << std::ctime(&now_time) << "] [" << levelToString(level) << "] " << msg << std::endl;
}
private:
std::mutex mtx_;
std::ofstream file_;
std::string levelToString(Level level) {
switch(level) {
case Level::TRACE: return "TRACE";
case Level::DEBUG: return "DEBUG";
case Level::INFO: return "INFO";
case Level::WARN: return "WARN";
case Level::ERROR: return "ERROR";
case Level::FATAL: return "FATAL";
default: return "UNKNOWN";
}
}
};
class Logger {
public:
Logger(const Logger&) = delete;
Logger& operator=(const Logger&) = delete;
static Logger& getInstance() {
static Logger instance;
return instance;
}
void addSink(std::unique_ptr<LogSink> sink) {
std::lock_guard<std::mutex> lock(mtx_);
sinks_.push_back(std::move(sink));
}
void setLevel(Level level) { level_ = level; }
template <typename... Args>
void log(Level level, Args&&... args) {
if (level < level_) return;
std::stringstream ss;
(ss << ... << std::forward<Args>(args));
std::lock_guard<std::mutex> lock(mtx_);
for (const auto& sink : sinks_) {
sink->log(level, ss.str());
}
}
private:
Logger() {
addSink(std::make_unique<ConsoleSink>());
addSink(std::make_unique<FileSink>("logs/addition.log"));
setLevel(Level::INFO);
}
std::vector<std::unique_ptr<LogSink>> sinks_;
Level level_;
std::mutex mtx_;
};
template <typename... Args> void trace(Args&&... args) { Logger::getInstance().log(Level::TRACE, std::forward<Args>(args)...); }
template <typename... Args> void debug(Args&&... args) { Logger::getInstance().log(Level::DEBUG, std::forward<Args>(args)...); }
template <typename... Args> void info(Args&&... args) { Logger::getInstance().log(Level::INFO, std::forward<Args>(args)...); }
template <typename... Args> void warn(Args&&... args) { Logger::getInstance().log(Level::WARN, std::forward<Args>(args)...); }
template <typename... Args> void error(Args&&... args) { Logger::getInstance().log(Level::ERROR, std::forward<Args>(args)...); }
template <typename... Args> void fatal(Args&&... args) { Logger::getInstance().log(Level::FATAL, std::forward<Args>(args)...); }
}
// 配置系统（单例+观察者模式）
namespace Config {
class ConfigObserver {
public:
virtual ~ConfigObserver() = default;
virtual void onConfigChanged(const std::string& key, const std::string& value) = 0;
};
class ConfigManager {
public:
static ConfigManager& getInstance() {
static ConfigManager instance;
return instance;
}
void load(const std::string& path) {
std::lock_guard<std::shared_mutex> lock(mtx_);
std::ifstream ifs(path);
if (ifs.is_open()) {
json j;
ifs >> j;
for (auto& [k, v] : j.items()) {
config_[k] = v.get<std::string>();
}
}
}
void save(const std::string& path) {
std::lock_guard<std::shared_mutex> lock(mtx_);
json j;
for (auto& [k, v] : config_) {
j[k] = v;
}
std::ofstream ofs(path);
ofs << j.dump(4);
}
std::string get(const std::string& key, const std::string& def = "") {
std::shared_lock<std::shared_mutex> lock(mtx_);
auto it = config_.find(key);
return it != config_.end() ? it->second : def;
}
void set(const std::string& key, const std::string& value) {
std::lock_guard<std::shared_mutex> lock(mtx_);
config_[key] = value;
notify(key, value);
}
void addObserver(ConfigObserver* observer) {
std::lock_guard<std::mutex> lock(obs_mtx_);
observers_.insert(observer);
}
void removeObserver(ConfigObserver* observer) {
std::lock_guard<std::mutex> lock(obs_mtx_);
observers_.erase(observer);
}
private:
ConfigManager() { load("config.json"); }
~ConfigManager() { save("config.json"); }
void notify(const std::string& key, const std::string& value) {
std::lock_guard<std::mutex> lock(obs_mtx_);
for (auto obs : observers_) {
obs->onConfigChanged(key, value);
}
}
std::map<std::string, std::string> config_;
std::set<ConfigObserver*> observers_;
std::shared_mutex mtx_;
std::mutex obs_mtx_;
};
}
// 数值包装系统（装饰器模式）
namespace Numeric {
template <typename T>
concept NumericType = std::is_arithmetic_v<T>;
template <NumericType T>
class Number {
public:
explicit Number(T value) : value_(value) {}
virtual ~Number() = default;
T getValue() const { return value_; }
virtual void setValue(T value) { value_ = value; }
virtual std::string toString() const {
return std::to_string(value_);
}
protected:
T value_;
};
template <NumericType T>
class ValidatedNumber : public Number<T> {
public:
using Validator = std::function<bool(T)>;
ValidatedNumber(T value, Validator validator, std::string errorMsg)
: Number<T>(value), validator_(std::move(validator)), errorMsg_(std::move(errorMsg)) {
if (!validator_(this->value_)) {
throw std::invalid_argument(errorMsg_);
}
}
void setValue(T value) override {
if (!validator_(value)) {
throw std::invalid_argument(errorMsg_);
}
Number<T>::setValue(value);
}
private:
Validator validator_;
std::string errorMsg_;
};
using PositiveInt = ValidatedNumber<int>;
PositiveInt makePositiveInt(int value) {
return PositiveInt(value, [](int v) { return v >= 0; }, "必须是非负整数");
}
}
// 加法策略系统（策略+工厂模式）
namespace Addition {
class Strategy {
public:
virtual ~Strategy() = default;
virtual int add(int a, int b) const = 0;
virtual std::string name() const = 0;
};
class BasicAdd : public Strategy {
public:
int add(int a, int b) const override {
Logger::trace("基础加法: ", a, "+", b);
return a + b;
}
std::string name() const override { return "BasicAdd"; }
};
class BitwiseAdd : public Strategy {
public:
int add(int a, int b) const override {
Logger::trace("位运算加法: ", a, "+", b);
int carry;
while (b != 0) {
carry = a & b;
a ^= b;
b = carry << 1;
}
return a;
}
std::string name() const override { return "BitwiseAdd"; }
};
class RecursiveAdd : public Strategy {
public:
int add(int a, int b) const override {
Logger::trace("递归加法: ", a, "+", b);
if (b == 0) return a;
return add(a ^ b, (a & b) << 1);
}
std::string name() const override { return "RecursiveAdd"; }
};
class ThreadedAdd : public Strategy {
public:
int add(int a, int b) const override {
Logger::trace("多线程加法: ", a, "+", b);
std::promise<int> prom;
auto fut = prom.get_future();
std::thread t([&](int x, int y) { prom.set_value(x + y); }, a, b);
t.join();
return fut.get();
}
std::string name() const override { return "ThreadedAdd"; }
};
class ProcessAdd : public Strategy {
public:
int add(int a, int b) const override {
Logger::trace("多进程加法: ", a, "+", b);
int pipefd[2];
if (pipe(pipefd) == -1) {
throw std::system_error(errno, std::system_category());
}
pid_t pid = fork();
if (pid == -1) {
throw std::system_error(errno, std::system_category());
}
if (pid == 0) {
close(pipefd[0]);
int result = a + b;
write(pipefd[1], &result, sizeof(result));
close(pipefd[1]);
exit(EXIT_SUCCESS);
} else {
close(pipefd[1]);
int result;
read(pipefd[0], &result, sizeof(result));
close(pipefd[0]);
waitpid(pid, nullptr, 0);
return result;
}
}
std::string name() const override { return "ProcessAdd"; }
};
class NetworkAdd : public Strategy {
public:
int add(int a, int b) const override {
Logger::trace("网络加法: ", a, "+", b);
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
throw std::system_error(errno, std::system_category());
}
struct sockaddr_in serv_addr;
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(12345);
inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);
std::thread server_thread(&NetworkAdd::runServer, a, b);
std::this_thread::sleep_for(100ms);
if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
server_thread.join();
throw std::system_error(errno, std::system_category());
}
int result;
read(sockfd, &result, sizeof(result));
close(sockfd);
server_thread.join();
return result;
}
std::string name() const override { return "NetworkAdd"; }
private:
static void runServer(int a, int b) {
int server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd < 0) return;
struct sockaddr_in address;
int addrlen = sizeof(address);
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(12345);
bind(server_fd, (struct sockaddr*)&address, sizeof(address));
listen(server_fd, 1);
int new_socket = accept(server_fd, (struct sockaddr*)&address, (socklen_t*)&addrlen);
if (new_socket < 0) return;
int result = a + b;
send(new_socket, &result, sizeof(result), 0);
close(new_socket);
close(server_fd);
}
};
class StrategyFactory {
public:
static std::unique_ptr<Strategy> create(const std::string& name) {
if (name == "BasicAdd") return std::make_unique<BasicAdd>();
if (name == "BitwiseAdd") return std::make_unique<BitwiseAdd>();
if (name == "RecursiveAdd") return std::make_unique<RecursiveAdd>();
if (name == "ThreadedAdd") return std::make_unique<ThreadedAdd>();
if (name == "ProcessAdd") return std::make_unique<ProcessAdd>();
if (name == "NetworkAdd") return std::make_unique<NetworkAdd>();
throw std::invalid_argument("未知策略: " + name);
}
};
}
// 加法器核心（外观模式+状态模式）
class AdvancedAdder : public Config::ConfigObserver {
public:
AdvancedAdder() {
Config::ConfigManager::getInstance().addObserver(this);
auto strategyName = Config::ConfigManager::getInstance().get("addition_strategy", "BasicAdd");
setStrategy(strategyName);
}
~AdvancedAdder() {
Config::ConfigManager::getInstance().removeObserver(this);
}
int add(int a, int b) {
try {
// 数值验证与包装
Numeric::PositiveInt numA = Numeric::makePositiveInt(a);
Numeric::PositiveInt numB = Numeric::makePositiveInt(b);
// 日志记录
logAdditionRequest(numA.getValue(), numB.getValue());
// 策略选择与执行
int result = currentStrategy_->add(numA.getValue(), numB.getValue());
// 结果记录
logAdditionResult(numA.getValue(), numB.getValue(), result);
return result;
} catch (const std::exception& e) {
Logger::error("加法失败: ", e.what());
throw;
}
}
void setStrategy(const std::string& name) {
currentStrategy_ = Addition::StrategyFactory::create(name);
Config::ConfigManager::getInstance().set("addition_strategy", name);
}
void onConfigChanged(const std::string& key, const std::string& value) override {
if (key == "addition_strategy") {
setStrategy(value);
}
}
private:
void logAdditionRequest(int a, int b) {
std::lock_guard<std::mutex> lock(logMtx_);
std::ofstream ofs("addition_requests.log", std::ios::app);
auto uuid = boost::uuids::random_generator()();
ofs << boost::uuids::to_string(uuid) << " - 请求: " << a << "+" << b << std::endl;
lastRequestId_ = boost::uuids::to_string(uuid);
}
void logAdditionResult(int a, int b, int result) {
std::lock_guard<std::mutex> lock(logMtx_);
std::ofstream ofs("addition_results.log", std::ios::app);
ofs << lastRequestId_ << " - 结果: " << a << "+" << b << "=" << result << std::endl;
}
std::unique_ptr<Addition::Strategy> currentStrategy_;
std::mutex logMtx_;
std::string lastRequestId_;
};
// 输入处理链（责任链模式）
namespace Input {
class Handler {
public:
virtual ~Handler() = default;
void setNext(std::unique_ptr<Handler> next) { next_ = std::move(next); }
virtual std::optional<int> handle(const std::string& input) {
return next_ ? next_->handle(input) : std::nullopt;
}
protected:
std::unique_ptr<Handler> next_;
};
class StringTrimHandler : public Handler {
public:
std::optional<int> handle(const std::string& input) override {
std::string trimmed = boost::algorithm::trim_copy(input);
return Handler::handle(trimmed);
}
};
class NumericInputHandler : public Handler {
public:
std::optional<int> handle(const std::string& input) override {
try {
return boost::lexical_cast<int>(input);
} catch (const boost::bad_lexical_cast&) {
return std::nullopt;
}
}
};
class InputProcessor {
public:
InputProcessor() {
auto trimHandler = std::make_unique<StringTrimHandler>();
auto numericHandler = std::make_unique<NumericInputHandler>();
trimHandler->setNext(std::move(numericHandler));
rootHandler_ = std::move(trimHandler);
}
std::optional<int> process(const std::string& input) {
return rootHandler_->handle(input);
}
private:
std::unique_ptr<Handler> rootHandler_;
};
}
// 主函数（仅处理两个输入数）
int main() {
try {
// 初始化组件
Logger::Logger::getInstance().setLevel(Logger::Level::DEBUG);
AdvancedAdder adder;
Input::InputProcessor inputProcessor;
// 读取两个输入数（极简输入）
int a, b;
std::cin >> a >> b;
// 处理输入
auto processedA = inputProcessor.process(std::to_string(a));
auto processedB = inputProcessor.process(std::to_string(b));
if (!processedA || !processedB) {
throw std::invalid_argument("无效输入");
}
// 执行加法（通过多层包装）
int result = adder.add(*processedA, *processedB);
// 输出结果（极简输出）
std::cout << result << std::endl;
return 0;
} catch (const std::exception& e) {
Logger::fatal("错误: ", e.what());
return 1;
}
}
这里空空如也
有帮助，赞一个