【创计作划】A+B 经典思路的具体实现

我们都知道，$a = a \times 1$。因此，我们创建一个变量代表答案，对 $a$ 和 $b$ 每次乘 $1$ 进行计数即可。
为了保证准确性与安全性，同时方便复用，我浅浅实现了一些类使用，还是很便捷的，都封装了。
以下是AC代码：

#include <iostream>
#include <vector>
#include <algorithm>
#include <memory>
#include <mutex>
#include <atomic>
#include <cmath>
#include <numeric>
#include <sstream>
#include <stdexcept>
using namespace std;

class CounterInterface {
public:
    virtual void increment() = 0;
    virtual int getCount() const = 0;
    virtual ~CounterInterface() = default;
};

class BaseCounter : public CounterInterface {
protected:
    atomic<int> count;
    mutable mutex mtx;

public:
    BaseCounter() : count(0) {}
    
    BaseCounter(const BaseCounter& other) {
        lock_guard<mutex> lock(other.mtx);
        count = other.count.load();
    }
    
    BaseCounter& operator=(const BaseCounter& other) {
        if (this != &other) {
            lock(mtx, other.mtx);
            lock_guard<mutex> lockThis(mtx, adopt_lock);
            lock_guard<mutex> lockOther(other.mtx, adopt_lock);
            count = other.count.load();
        }
        return *this;
    }
    
    void increment() override {
        lock_guard<mutex> lock(mtx);
        count.fetch_add(1);
    }
    
    int getCount() const override {
        lock_guard<mutex> lock(mtx);
        return count.load();
    }
};

class LoggingCounter : public CounterInterface {
private:
    unique_ptr<CounterInterface> counter;
    
public:
    explicit LoggingCounter(unique_ptr<CounterInterface> cnt) 
        : counter(move(cnt)) {}
    
    void increment() override {
        counter->increment();
        stringstream ss;
        ss << "Incremented. Current count: " << counter->getCount();
    }
    
    int getCount() const override {
        return counter->getCount();
    }
};

class CountingStrategy {
public:
    virtual void execute(CounterInterface& counter, int value) = 0;
    virtual ~CountingStrategy() = default;
};

class SingleThreadedStrategy : public CountingStrategy {
public:
    void execute(CounterInterface& counter, int value) override {
        if (value < 0) {
            throw invalid_argument("Value must be non-negative");
        }
        for (int i = 1; i <= value; ++i) {
            counter.increment();
        }
    }
};

class CountingStrategyFactory {
public:
    enum class StrategyType {
        SINGLE_THREADED
    };
    
    static unique_ptr<CountingStrategy> createStrategy(StrategyType type) {
        switch (type) {
            case StrategyType::SINGLE_THREADED:
                return make_unique<SingleThreadedStrategy>();
            default:
                throw invalid_argument("Invalid strategy type");
        }
    }
};

class CountManager {
private:
    unique_ptr<CounterInterface> counter;
    unique_ptr<CountingStrategy> strategy;
    
public:
    CountManager(unique_ptr<CounterInterface> cnt, 
                unique_ptr<CountingStrategy> strat)
        : counter(move(cnt)), strategy(move(strat)) {}
    
    void processCount(int value) {
        try {
            strategy->execute(*counter, value);
        } catch (const exception& e) {
            cerr << "Error processing count: " << e.what() << endl;
            throw;
        }
    }
    
    int getTotal() const {
        return counter->getCount();
    }
};

bool validateInput(int value) {
    if (value < 0) {
        cerr << "Input value must be non-negative" << endl;
        return false;
    }
    return true;
}

int main() {
    try {
        int a, b;
        cin >> a >> b;
        if (!validateInput(a) || !validateInput(b)) {
            return 1;
        }
        auto baseCounter = make_unique<BaseCounter>();
        auto loggingCounter = make_unique<LoggingCounter>(move(baseCounter));
        auto strategyA = CountingStrategyFactory::createStrategy(CountingStrategyFactory::StrategyType::SINGLE_THREADED);
        CountManager managerA(move(loggingCounter), move(strategyA));
        managerA.processCount(a);
        auto baseCounter2 = make_unique<BaseCounter>();
        for (int i = 0; i < managerA.getTotal(); ++i) {
            baseCounter2->increment();
        }
        auto loggingCounter2 = make_unique<LoggingCounter>(move(baseCounter2));
        auto strategyB = CountingStrategyFactory::createStrategy(CountingStrategyFactory::StrategyType::SINGLE_THREADED);
        CountManager managerB(move(loggingCounter2), move(strategyB));
        managerB.processCount(b);
        cout << managerB.getTotal() << endl;
    } catch (const exception& e) {
        cerr << "Program error: " << e.what() << endl;
        return 1;
    } catch (...) {
        cerr << "Unknown error occurred" << endl;
        return 1;
    }
    return 0;
}