为啥错了！
原题链接：1.A+B problem
2026-02-28 15:00:57
发布于：浙江
22阅读
0回复
0点赞
为啥错了
#include <algorithm>
#include <cassert>
#include <cctype>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <regex>
#include <bitset>
#include <deque>
#include <list>
#include <forward_list>
#include <condition_variable>
#include <atomic>
#include <future>
#include <ratio>
#include <system_error>
#include <valarray>
#include <cwchar>
#include <cwctype>
#include <complex>
#include <numeric>
#define ENABLE_VERBOSE_LOGGING 1
#define ENABLE_TIMING 1
#define ENABLE_THREAD_SAFETY 1
#define USE_MULTITHREADING 0
#define MAX_ITERATIONS 1
#define MAX_BUFFER_SIZE 4096
#define DEFAULT_LOG_LEVEL 0
#define MAX_RETRY_COUNT 3
#define MIN_INPUT_VALUE 0
#define MAX_INPUT_VALUE 1000000000
#define MAGIC_SEED 1337
#define PROGRAM_BUILD_DATE __DATE__
#define PROGRAM_BUILD_TIME __TIME__
#define START_OF_PROGRAM do {
#define END_OF_PROGRAM } while(0)
#define BEGIN_NAMESPACE namespace {
#define END_NAMESPACE }
#define UNUSED(x) ((void)(x))
#define IGNORE_RETURN_VALUE(x) if (x) {}
#define LIKELY(x) (__builtin_expect(!!(x), 1))
#define UNLIKELY(x) (__builtin_expect(!!(x), 0))
#define SAFE_DELETE(ptr) if (ptr) { delete ptr; ptr = nullptr; }
#define SAFE_DELETE_ARRAY(ptr) if (ptr) { delete[] ptr; ptr = nullptr; }
#define LOCK_GLOBAL_MUTEX std::lock_guard<std::mutex> lock(g_global_mutex)
#define THROW_IF_NULL(ptr, msg) if (!ptr) throw std::invalid_argument(msg)
#define PROGRAM_NAME "A+B Solver - Ultra Overengineered Edition"
#define PROGRAM_VERSION "10.0.0"
#define PROGRAM_AUTHOR "Dr. Extreme Overkill"
#define PROGRAM_LICENSE "GPLv3+ with MAX verbosity clause"
#define PROGRAM_COPYRIGHT "Copyright (C) 2026 Overkill Software Labs"
#define PROGRAM_DESCRIPTION "The most unnecessarily complex A+B solver in the known universe"
const char* const kProgramName = PROGRAM_NAME;
const char* const kProgramVersion = PROGRAM_VERSION;
const char* const kProgramAuthor = PROGRAM_AUTHOR;
const char* const kProgramLicense = PROGRAM_LICENSE;
const char* const kProgramCopyright = PROGRAM_COPYRIGHT;
const char* const kProgramDescription = PROGRAM_DESCRIPTION;
const char* const kProgramBuildDate = PROGRAM_BUILD_DATE;
const char* const kProgramBuildTime = PROGRAM_BUILD_TIME;
const double kPi = 3.14159265358979323846264338327950288;
const double kEulerNumber = 2.71828182845904523536028747135266249;
const double kGoldenRatio = 1.61803398874989484820458683436563811;
const double kPlankConstant = 6.62607015e-34;
const double kSpeedOfLight = 299792458.0;
const double kGravitationalConstant = 6.67430e-11;
const float kFloatZero = 0.0f;
const float kFloatOne = 1.0f;
const int kMagicNumber = 42;
const int kAnswerToLife = 42;
const int kRandomSeed = 4242;
const char kGreetingMessage[] = "Welcome to the ULTRA over-engineered A+B solver!\n";
const char kFarewellMessage[] = "Thank you for using our OVERKILL software. Have a nice day!\n";
const char kLoadingMessage[] = "Initializing over 9000 components...\n";
const char kCompletionMessage[] = "All unnecessary components initialized successfully!\n";
static bool g_initialized = false;
static std::mutex g_global_mutex;
static std::atomic<int> g_log_level{0};
static std::atomic<bool> g_is_running{false};
static std::atomic<long long> g_total_operations{0};
static std::unordered_map<std::string, std::string> g_config_map;
static std::vector<std::string> g_dummy_logs;
static std::array<int, 100> g_dummy_array = {0};
static std::deque<int> g_dummy_deque;
static std::list<int> g_dummy_list;
static std::forward_list<int> g_dummy_forward_list;
using Integer = int;
using UnsignedInteger = unsigned int;
using LongInteger = long long;
using UnsignedLongInteger = unsigned long long;
using ShortInteger = short;
using UnsignedShortInteger = unsigned short;
using CharType = char;
using WideCharType = wchar_t;
using FloatType = float;
using DoubleType = double;
using LongDoubleType = long double;
using InputPair = std::pair<Integer, Integer>;
using ResultType = Integer;
using Logger = std::ostream;
using ChronoClock = std::chrono::high_resolution_clock;
using TimePoint = ChronoClock::time_point;
using DurationMs = std::chrono::duration<double, std::milli>;
using DurationUs = std::chrono::duration<double, std::micro>;
using DurationNs = std::chrono::duration<double, std::nano>;
using BufferType = std::array<char, MAX_BUFFER_SIZE>;
using StringVector = std::vector<std::string>;
using IntVector = std::vector<Integer>;
using IntSet = std::set<Integer>;
using IntMap = std::map<Integer, std::string>;
using IntUnorderedMap = std::unordered_map<Integer, std::string>;
using BitSet64 = std::bitset<64>;
using ComplexDouble = std::complex<double>;
using ValArrayInt = std::valarray<Integer>;
enum class ErrorCode : int {
SUCCESS = 0,
INVALID_INPUT = 1,
DIVISION_BY_ZERO = 2,
OUT_OF_MEMORY = 3,
UNKNOWN_ERROR = 99,
TIMEOUT = 4,
PERMISSION_DENIED = 5,
RESOURCE_BUSY = 6,
CONNECTION_REFUSED = 7,
INVALID_ARGUMENT = 8,
OUT_OF_RANGE = 9,
NOT_IMPLEMENTED = 10
};
enum class AdditionStrategyType : uint8_t {
SIMPLE,
BITWISE,
TEMPLATE_META,
MULTITHREADED,
RECURSIVE,
FUNCTIONAL,
ITERATIVE,
VECTORIZED,
GPU_ACCELERATED,
NUM_STRATEGIES
};
enum class LogLevel : int {
TRACE = 0,
DEBUG = 1,
INFO = 2,
WARNING = 3,
ERROR = 4,
FATAL = 5
};
enum class Weekday {
Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
};
enum class Month {
January, February, March, April, May, June, July, August, September, October, November, December
};
enum class Color {
Red, Green, Blue, Yellow, Cyan, Magenta, Black, White, Gray, Silver, Maroon, Purple, Olive, Teal, Navy
};
enum class InputSource {
STDIN,
FILE,
NETWORK,
COMMAND_LINE,
FIXED_STRING
};
enum class OutputFormat {
PLAIN_TEXT,
JSON,
XML,
CSV,
YAML,
BINARY
};
struct MathConstants {
static constexpr double PI = 3.14159265358979323846264338327950288;
static constexpr double E = 2.71828182845904523536028747135266249;
static constexpr double GOLDEN_RATIO = 1.61803398874989484820458683436563811;
static constexpr double PLANCK_CONSTANT = 6.62607015e-34;
static constexpr double SPEED_OF_LIGHT = 299792458.0;
static constexpr double GRAVITATIONAL_CONSTANT = 6.67430e-11;
static constexpr int MAX_INT = std::numeric_limits<int>::max();
static constexpr int MIN_INT = std::numeric_limits<int>::min();
static constexpr long long MAX_LONG_LONG = std::numeric_limits<long long>::max();
static constexpr long long MIN_LONG_LONG = std::numeric_limits<long long>::min();
static constexpr float MAX_FLOAT = std::numeric_limits<float>::max();
static constexpr float MIN_FLOAT = std::numeric_limits<float>::min();
};
struct Point2D {
double x, y;
Point2D() : x(0.0), y(0.0) {}
Point2D(double x_, double y_) : x(x_), y(y_) {}
double distance(const Point2D& other) const {
return std::sqrt(std::pow(x - other.x, 2) + std::pow(y - other.y, 2));
}
};
struct Point3D {
double x, y, z;
Point3D() : x(0.0), y(0.0), z(0.0) {}
Point3D(double x_, double y_, double z_) : x(x_), y(y_), z(z_) {}
double distance(const Point3D& other) const {
return std::sqrt(std::pow(x - other.x, 2) + std::pow(y - other.y, 2) + std::pow(z - other.z, 2));
}
};
struct LineSegment {
Point2D start, end;
double length() const { return start.distance(end); }
};
struct Circle {
Point2D center;
double radius;
double area() const { return MathConstants::PI * std::pow(radius, 2); }
double circumference() const { return 2 * MathConstants::PI * radius; }
};
struct Rectangle {
Point2D top_left;
Point2D bottom_right;
double width() const { return bottom_right.x - top_left.x; }
double height() const { return bottom_right.y - top_left.y; }
double area() const { return width() * height(); }
};
struct ApplicationConfig {
std::string log_file_path;
int log_level;
bool enable_timing;
bool enable_thread_safety;
int max_retry_count;
InputSource input_source;
OutputFormat output_format;
ApplicationConfig()
: log_file_path(""), log_level(0), enable_timing(true),
enable_thread_safety(true), max_retry_count(3),
input_source(InputSource::STDIN), output_format(OutputFormat::PLAIN_TEXT) {}
};
struct PerformanceMetrics {
TimePoint start_time;
TimePoint end_time;
DurationMs total_duration;
int operation_count;
double operations_per_second;
PerformanceMetrics()
: start_time(ChronoClock::now()), end_time(ChronoClock::now()),
total_duration(DurationMs::zero()), operation_count(0),
operations_per_second(0.0) {}
};
namespace OverkillSoft {
namespace APlusB {
namespace Core {
namespace Arithmetic {
namespace details {
template<typename T>
struct IsInteger : std::false_type {};
template<> struct IsInteger<char> : std::true_type {};
template<> struct IsInteger<signed char> : std::true_type {};
template<> struct IsInteger<unsigned char> : std::true_type {};
template<> struct IsInteger<short> : std::true_type {};
template<> struct IsInteger<unsigned short> : std::true_type {};
template<> struct IsInteger<int> : std::true_type {};
template<> struct IsInteger<unsigned int> : std::true_type {};
template<> struct IsInteger<long> : std::true_type {};
template<> struct IsInteger<unsigned long> : std::true_type {};
template<> struct IsInteger<long long> : std::true_type {};
template<> struct IsInteger<unsigned long long> : std::true_type {};
#ifdef __cpp_char8_t
template<> struct IsInteger<char8_t> : std::true_type {};
#endif
#ifdef __cpp_lib_byte
template<> struct IsInteger<std::byte> : std::true_type {};
#endif
template<typename T>
struct IsFloatingPoint : std::false_type {};
template<> struct IsFloatingPoint<float> : std::true_type {};
template<> struct IsFloatingPoint<double> : std::true_type {};
template<> struct IsFloatingPoint<long double> : std::true_type {};
template<typename T>
struct IsSigned : std::integral_constant<bool, (T(-1) < T(0))> {};
template<typename T, typename U>
struct IsSameType : std::false_type {};
template<typename T>
struct IsSameType<T, T> : std::true_type {};
template<int N>
struct Factorial {
static constexpr int value = N * Factorial<N-1>::value;
};
template<>
struct Factorial<0> {
static constexpr int value = 1;
};
template<int... Args>
struct SumVariadic {
static constexpr int value = (Args + ...);
};
}
class AdditionStrategy {
public:
virtual ~AdditionStrategy() = default;
virtual ResultType execute(Integer a, Integer b) const = 0;
virtual std::string name() const = 0;
virtual std::string description() const { return "Base addition strategy"; }
};
class SimpleAdditionStrategy : public AdditionStrategy {
public:
ResultType execute(Integer a, Integer b) const override {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[SimpleAdditionStrategy] Adding " << a << " and " << b << " using operator+." << std::endl;
#endif
g_total_operations.fetch_add(1);
return a + b;
}
std::string name() const override { return "SimpleAddition"; }
std::string description() const override { return "Simple addition using built-in operator+"; }
};
class BitwiseAdditionStrategy : public AdditionStrategy {
public:
ResultType execute(Integer a, Integer b) const override {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[BitwiseAdditionStrategy] Adding " << a << " and " << b << " using bitwise operations." << std::endl;
#endif
g_total_operations.fetch_add(1);
Integer x = a, y = b;
while (y != 0) {
Integer carry = x & y;
x = x ^ y;
y = carry << 1;
}
return x;
}
std::string name() const override { return "BitwiseAddition"; }
std::string description() const override { return "Addition using bitwise XOR and carry operations"; }
};
class RecursiveAdditionStrategy : public AdditionStrategy {
private:
ResultType add_recursive(Integer a, Integer b) const {
if (b == 0) return a;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[RecursiveAdditionStrategy] Recursion depth: " << (b > 0 ? b : -b) << std::endl;
#endif
if (b > 0)
return add_recursive(a + 1, b - 1);
else if (b < 0)
return add_recursive(a - 1, b + 1);
return a;
}
public:
ResultType execute(Integer a, Integer b) const override {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[RecursiveAdditionStrategy] Starting recursive addition." << std::endl;
#endif
g_total_operations.fetch_add(1);
return add_recursive(a, b);
}
std::string name() const override { return "RecursiveAddition"; }
std::string description() const override { return "Recursive addition by increment/decrement"; }
};
class MultithreadedAdditionStrategy : public AdditionStrategy {
private:
mutable std::mutex m_mutex;
mutable ResultType m_result;
mutable bool m_completed;
void thread_func(Integer a, Integer b) const {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[MultithreadedAdditionStrategy] Worker thread started." << std::endl;
#endif
ResultType res = a + b;
{
std::lock_guard<std::mutex> lock(m_mutex);
m_result = res;
m_completed = true;
}
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[MultithreadedAdditionStrategy] Worker thread finished." << std::endl;
#endif
}
public:
MultithreadedAdditionStrategy() : m_result(0), m_completed(false) {}
ResultType execute(Integer a, Integer b) const override {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[MultithreadedAdditionStrategy] Creating worker thread." << std::endl;
#endif
g_total_operations.fetch_add(1);
m_completed = false;
std::thread worker(&MultithreadedAdditionStrategy::thread_func, this, a, b);
worker.join();
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[MultithreadedAdditionStrategy] Worker thread joined." << std::endl;
#endif
return m_result;
}
std::string name() const override { return "MultithreadedAddition"; }
std::string description() const override { return "Addition using a separate worker thread"; }
};
class IterativeAdditionStrategy : public AdditionStrategy {
public:
ResultType execute(Integer a, Integer b) const override {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[IterativeAdditionStrategy] Starting iterative addition." << std::endl;
#endif
g_total_operations.fetch_add(1);
ResultType res = a;
if (b > 0) {
for (int i = 0; i < b; ++i) {
res++;
}
} else if (b < 0) {
for (int i = 0; i < -b; ++i) {
res--;
}
}
return res;
}
std::string name() const override { return "IterativeAddition"; }
std::string description() const override { return "Iterative addition by increment/decrement"; }
};
template<int A, int B>
struct TemplateMetaAdder {
static constexpr int value = A + B;
};
class TemplateMetaAdditionStrategy : public AdditionStrategy {
public:
ResultType execute(Integer a, Integer b) const override {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[TemplateMetaAdditionStrategy] This strategy only works at compile time. Falling back to simple addition." << std::endl;
#endif
g_total_operations.fetch_add(1);
return a + b;
}
std::string name() const override { return "TemplateMetaAddition"; }
std::string description() const override { return "Compile-time template metaprogramming addition (fallback to simple)"; }
};
class FunctionalAdditionStrategy : public AdditionStrategy {
public:
ResultType execute(Integer a, Integer b) const override {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[FunctionalAdditionStrategy] Using functional style addition." << std::endl;
#endif
g_total_operations.fetch_add(1);
auto add = [](Integer x, Integer y) { return x + y; };
return add(a, b);
}
std::string name() const override { return "FunctionalAddition"; }
std::string description() const override { return "Addition using lambda function (functional style)"; }
};
}
class Adder {
private:
std::unique_ptr<Arithmetic::AdditionStrategy> m_strategy;
mutable std::mutex m_mutex;
PerformanceMetrics m_metrics;
std::vector<ResultType> m_history;
int m_strategy_change_count = 0;
public:
explicit Adder(Arithmetic::AdditionStrategy* strategy) : m_strategy(strategy) {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[Adder] Constructed with strategy: " << (strategy ? strategy->name() : "nullptr") << std::endl;
#endif
THROW_IF_NULL(strategy, "Addition strategy cannot be null");
m_metrics.start_time = ChronoClock::now();
}
Adder(const Adder&) = delete;
Adder(Adder&& other) noexcept
: m_strategy(std::move(other.m_strategy)),
m_metrics(other.m_metrics),
m_history(std::move(other.m_history)),
m_strategy_change_count(other.m_strategy_change_count) {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[Adder] Move constructed." << std::endl;
#endif
}
~Adder() {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[Adder] Destructor called. Strategy change count: " << m_strategy_change_count << std::endl;
#endif
m_metrics.end_time = ChronoClock::now();
m_metrics.total_duration = m_metrics.end_time - m_metrics.start_time;
}
Adder& operator=(const Adder&) = delete;
Adder& operator=(Adder&& other) noexcept {
if (this != &other) {
LOCK_GLOBAL_MUTEX;
m_strategy = std::move(other.m_strategy);
m_metrics = other.m_metrics;
m_history = std::move(other.m_history);
m_strategy_change_count = other.m_strategy_change_count;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[Adder] Move assignment." << std::endl;
#endif
}
return *this;
}
ResultType add(Integer a, Integer b) const {
#if ENABLE_THREAD_SAFETY
std::lock_guard<std::mutex> lock(m_mutex);
#endif
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[Adder] Performing addition using strategy: " << m_strategy->name() << std::endl;
#endif
auto start = ChronoClock::now();
ResultType res = m_strategy->execute(a, b);
auto end = ChronoClock::now();
DurationMs elapsed = end - start;
#if ENABLE_TIMING
std::cerr << "[Adder] Addition took " << elapsed.count() << " ms" << std::endl;
#endif
const_cast<Adder*>(this)->m_history.push_back(res);
const_cast<Adder*>(this)->m_metrics.operation_count++;
const_cast<Adder*>(this)->m_metrics.operations_per_second =
m_metrics.operation_count / m_metrics.total_duration.count() * 1000;
return res;
}
void setStrategy(Arithmetic::AdditionStrategy* strategy) {
THROW_IF_NULL(strategy, "New strategy cannot be null");
LOCK_GLOBAL_MUTEX;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[Adder] Changing strategy from "
<< (m_strategy ? m_strategy->name() : "null")
<< " to " << strategy->name() << std::endl;
#endif
m_strategy.reset(strategy);
m_strategy_change_count++;
}
std::string getCurrentStrategyName() const {
LOCK_GLOBAL_MUTEX;
return m_strategy ? m_strategy->name() : "none";
}
std::string getCurrentStrategyDescription() const {
LOCK_GLOBAL_MUTEX;
return m_strategy ? m_strategy->description() : "none";
}
const std::vector<ResultType>& getHistory() const {
return m_history;
}
const PerformanceMetrics& getMetrics() const {
return m_metrics;
}
int getStrategyChangeCount() const {
return m_strategy_change_count;
}
void clearHistory() {
LOCK_GLOBAL_MUTEX;
m_history.clear();
}
};
namespace Input {
class InputReader {
public:
virtual ~InputReader() = default;
virtual std::string readLine() = 0;
virtual bool isGood() const = 0;
virtual void reset() = 0;
virtual std::string getSourceName() const = 0;
};
class StdinReader : public InputReader {
private:
std::istream& m_inputStream;
bool m_good;
int m_read_count;
public:
explicit StdinReader(std::istream& is = std::cin)
: m_inputStream(is), m_good(is.good()), m_read_count(0) {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[StdinReader] Created, using stream: " << (void*)&m_inputStream << std::endl;
#endif
}
std::string readLine() override {
LOCK_GLOBAL_MUTEX;
std::string line;
std::getline(m_inputStream, line);
m_good = m_inputStream.good();
m_read_count++;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[StdinReader] Read line (" << m_read_count << "): \"" << line << "\"" << std::endl;
#endif
return line;
}
bool isGood() const override {
return m_good && m_inputStream.good();
}
void reset() override {
LOCK_GLOBAL_MUTEX;
m_inputStream.clear();
m_inputStream.seekg(0);
m_good = true;
m_read_count = 0;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[StdinReader] Reset to initial state" << std::endl;
#endif
}
std::string getSourceName() const override {
return "Standard Input (stdin)";
}
int getReadCount() const {
return m_read_count;
}
};
class FixedStringReader : public InputReader {
private:
std::string m_fixedLine;
bool m_good;
int m_read_count;
public:
explicit FixedStringReader(const std::string& line)
: m_fixedLine(line), m_good(true), m_read_count(0) {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[FixedStringReader] Created with fixed line: \"" << line << "\"" << std::endl;
#endif
}
std::string readLine() override {
LOCK_GLOBAL_MUTEX;
m_read_count++;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[FixedStringReader] Returning fixed line (" << m_read_count << "): \"" << m_fixedLine << "\"" << std::endl;
#endif
m_good = false;
return m_fixedLine;
}
bool isGood() const override {
return m_good;
}
void reset() override {
LOCK_GLOBAL_MUTEX;
m_good = true;
m_read_count = 0;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[FixedStringReader] Reset to initial state" << std::endl;
#endif
}
std::string getSourceName() const override {
return "Fixed String";
}
int getReadCount() const {
return m_read_count;
}
};
class FileReader : public InputReader {
private:
std::ifstream m_file;
std::string m_filename;
bool m_good;
int m_read_count;
public:
explicit FileReader(const std::string& filename)
: m_filename(filename), m_good(false), m_read_count(0) {
m_file.open(filename);
m_good = m_file.good();
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[FileReader] Created for file: " << filename << ". Success: " << std::boolalpha << m_good << std::endl;
#endif
}
std::string readLine() override {
LOCK_GLOBAL_MUTEX;
std::string line;
if (m_file.good()) {
std::getline(m_file, line);
m_good = m_file.good();
m_read_count++;
}
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[FileReader] Read line (" << m_read_count << "): \"" << line << "\"" << std::endl;
#endif
return line;
}
bool isGood() const override {
return m_good && m_file.good();
}
void reset() override {
LOCK_GLOBAL_MUTEX;
m_file.close();
m_file.open(m_filename);
m_good = m_file.good();
m_read_count = 0;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[FileReader] Reset to initial state" << std::endl;
#endif
}
std::string getSourceName() const override {
return "File: " + m_filename;
}
int getReadCount() const {
return m_read_count;
}
~FileReader() {
m_file.close();
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[FileReader] File closed: " << m_filename << std::endl;
#endif
}
};
class CompositeReader : public InputReader {
private:
std::vector<std::unique_ptr<InputReader>> m_readers;
size_t m_currentIndex = 0;
int m_total_read_count = 0;
public:
void addReader(std::unique_ptr<InputReader> reader) {
LOCK_GLOBAL_MUTEX;
m_readers.push_back(std::move(reader));
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[CompositeReader] Added new reader: " << m_readers.back()->getSourceName() << std::endl;
#endif
}
std::string readLine() override {
LOCK_GLOBAL_MUTEX;
while (m_currentIndex < m_readers.size()) {
if (m_readers[m_currentIndex]->isGood()) {
std::string line = m_readers[m_currentIndex]->readLine();
m_total_read_count++;
return line;
} else {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[CompositeReader] Reader " << m_currentIndex << " exhausted, moving to next" << std::endl;
#endif
m_currentIndex++;
}
}
m_total_read_count++;
return "";
}
bool isGood() const override {
for (size_t i = m_currentIndex; i < m_readers.size(); ++i) {
if (m_readers[i]->isGood()) return true;
}
return false;
}
void reset() override {
LOCK_GLOBAL_MUTEX;
m_currentIndex = 0;
m_total_read_count = 0;
for (auto& reader : m_readers) {
reader->reset();
}
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[CompositeReader] All readers reset to initial state" << std::endl;
#endif
}
std::string getSourceName() const override {
std::string names = "Composite ( ";
for (size_t i = 0; i < m_readers.size(); ++i) {
names += m_readers[i]->getSourceName();
if (i < m_readers.size() - 1) names += ", ";
}
names += " )";
return names;
}
int getTotalReadCount() const {
return m_total_read_count;
}
};
}
namespace Parsing {
class Parser {
public:
virtual ~Parser() = default;
virtual InputPair parse(const std::string& input) = 0;
virtual std::string getName() const = 0;
virtual std::vector<std::string> getSupportedFormats() const = 0;
};
class WhitespaceParser : public Parser {
private:
std::string trim(const std::string& s) const {
size_t start = s.find_first_not_of(" \t\n\r");
size_t end = s.find_last_not_of(" \t\n\r");
if (start == std::string::npos) return "";
return s.substr(start, end - start + 1);
}
public:
InputPair parse(const std::string& input) override {
LOCK_GLOBAL_MUTEX;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[WhitespaceParser] Parsing string: \"" << input << "\"" << std::endl;
#endif
std::string trimmed = trim(input);
std::istringstream iss(trimmed);
Integer a, b;
if (!(iss >> a >> b)) {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[WhitespaceParser] Parsing failed." << std::endl;
#endif
throw std::invalid_argument("Input does not contain two integers");
}
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[WhitespaceParser] Parsed numbers: " << a << " and " << b << std::endl;
#endif
return std::make_pair(a, b);
}
std::string getName() const override {
return "WhitespaceParser";
}
std::vector<std::string> getSupportedFormats() const override {
return {"integer integer (whitespace separated)"};
}
};
template<char Delimiter = ' '>
class DelimitedParser : public Parser {
public:
InputPair parse(const std::string& input) override {
LOCK_GLOBAL_MUTEX;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[DelimitedParser<" << Delimiter << ">] Parsing with delimiter '" << Delimiter << "'" << std::endl;
#endif
std::stringstream ss(input);
std::string token;
std::vector<std::string> tokens;
while (std::getline(ss, token, Delimiter)) {
if (!token.empty()) {
tokens.push_back(token);
}
}
if (tokens.size() != 2) {
throw std::invalid_argument("Expected exactly two numbers");
}
Integer a = std::stoi(tokens[0]);
Integer b = std::stoi(tokens[1]);
return std::make_pair(a, b);
}
std::string getName() const override {
return "DelimitedParser<" + std::string(1, Delimiter) + ">";
}
std::vector<std::string> getSupportedFormats() const override {
return {"integer" + std::string(1, Delimiter) + "integer (delimited by '" + std::string(1, Delimiter) + "')"};
}
};
class RegexParser : public Parser {
private:
std::regex m_pattern;
public:
RegexParser() : m_pattern(R"(^\s*([+-]?\d+)\s+([+-]?\d+)\s*$)") {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[RegexParser] Constructed with regex pattern: " << R"(^\s*([+-]?\d+)\s+([+-]?\d+)\s*$)" << std::endl;
#endif
}
InputPair parse(const std::string& input) override {
LOCK_GLOBAL_MUTEX;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[RegexParser] Parsing string with regex: \"" << input << "\"" << std::endl;
#endif
std::smatch match;
if (!std::regex_match(input, match, m_pattern) || match.size() != 3) {
throw std::invalid_argument("Input does not match expected pattern: " + input);
}
Integer a = std::stoi(match[1].str());
Integer b = std::stoi(match[2].str());
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[RegexParser] Parsed numbers: " << a << " and " << b << std::endl;
#endif
return std::make_pair(a, b);
}
std::string getName() const override {
return "RegexParser";
}
std::vector<std::string> getSupportedFormats() const override {
return {"integer integer (whitespace separated, regex validated)"};
}
};
class CsvParser : public Parser {
public:
InputPair parse(const std::string& input) override {
LOCK_GLOBAL_MUTEX;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[CsvParser] Parsing CSV string: \"" << input << "\"" << std::endl;
#endif
DelimitedParser<','> parser;
return parser.parse(input);
}
std::string getName() const override {
return "CsvParser";
}
std::vector<std::string> getSupportedFormats() const override {
return {"integer,integer (CSV format)"};
}
};
}
namespace Validation {
class Validator {
public:
virtual ~Validator() = default;
virtual bool validate(const InputPair& pair) const = 0;
virtual std::string errorMessage() const = 0;
virtual std::string getName() const = 0;
virtual std::string getDescription() const = 0;
};
class IntRangeValidator : public Validator {
private:
mutable std::string m_lastError;
Integer m_min;
Integer m_max;
public:
IntRangeValidator(Integer min_val = MIN_INPUT_VALUE, Integer max_val = MAX_INPUT_VALUE)
: m_min(min_val), m_max(max_val) {}
bool validate(const InputPair& pair) const override {
LOCK_GLOBAL_MUTEX;
Integer a = pair.first;
Integer b = pair.second;
if (a < m_min || a > m_max) {
m_lastError = "First number out of range [" + std::to_string(m_min) + ", " + std::to_string(m_max) + "]";
return false;
}
if (b < m_min || b > m_max) {
m_lastError = "Second number out of range [" + std::to_string(m_min) + ", " + std::to_string(m_max) + "]";
return false;
}
return true;
}
std::string errorMessage() const override { return m_lastError; }
std::string getName() const override { return "IntRangeValidator"; }
std::string getDescription() const override {
return "Validates that input integers are within range [" + std::to_string(m_min) + ", " + std::to_string(m_max) + "]";
}
};
class PositiveNumberValidator : public Validator {
private:
mutable std::string m_lastError;
public:
bool validate(const InputPair& pair) const override {
LOCK_GLOBAL_MUTEX;
if (pair.first < 0) {
m_lastError = "First number is negative: " + std::to_string(pair.first);
return false;
}
if (pair.second < 0) {
m_lastError = "Second number is negative: " + std::to_string(pair.second);
return false;
}
return true;
}
std::string errorMessage() const override { return m_lastError; }
std::string getName() const override { return "PositiveNumberValidator"; }
std::string getDescription() const override {
return "Validates that input integers are non-negative (>= 0)";
}
};
class NonZeroValidator : public Validator {
private:
mutable std::string m_lastError;
public:
bool validate(const InputPair& pair) const override {
LOCK_GLOBAL_MUTEX;
if (pair.first == 0) {
m_lastError = "First number is zero (not allowed)";
return false;
}
if (pair.second == 0) {
m_lastError = "Second number is zero (not allowed)";
return false;
}
return true;
}
std::string errorMessage() const override { return m_lastError; }
std::string getName() const override { return "NonZeroValidator"; }
std::string getDescription() const override {
return "Validates that input integers are non-zero";
}
};
class SumRangeValidator : public Validator {
private:
mutable std::string m_lastError;
Integer m_min_sum;
Integer m_max_sum;
public:
SumRangeValidator(Integer min_sum = 0, Integer max_sum = 2000000000)
: m_min_sum(min_sum), m_max_sum(max_sum) {}
bool validate(const InputPair& pair) const override {
LOCK_GLOBAL_MUTEX;
Integer sum = pair.first + pair.second;
if (sum < m_min_sum || sum > m_max_sum) {
m_lastError = "Sum of numbers out of range [" + std::to_string(m_min_sum) + ", " + std::to_string(m_max_sum) + "]. Calculated sum: " + std::to_string(sum);
return false;
}
return true;
}
std::string errorMessage() const override { return m_lastError; }
std::string getName() const override { return "SumRangeValidator"; }
std::string getDescription() const override {
return "Validates that sum of input integers is within range [" + std::to_string(m_min_sum) + ", " + std::to_string(m_max_sum) + "]";
}
};
class CompositeValidator : public Validator {
private:
std::vector<std::unique_ptr<Validator>> m_validators;
mutable std::string m_lastError;
public:
void addValidator(std::unique_ptr<Validator> validator) {
LOCK_GLOBAL_MUTEX;
m_validators.push_back(std::move(validator));
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[CompositeValidator] Added validator: " << m_validators.back()->getName() << std::endl;
#endif
}
bool validate(const InputPair& pair) const override {
LOCK_GLOBAL_MUTEX;
for (const auto& v : m_validators) {
if (!v->validate(pair)) {
m_lastError = v->getName() + ": " + v->errorMessage();
return false;
}
}
return true;
}
std::string errorMessage() const override { return m_lastError; }
std::string getName() const override { return "CompositeValidator"; }
std::string getDescription() const override {
std::string desc = "Composite validator containing: ";
for (size_t i = 0; i < m_validators.size(); ++i) {
desc += m_validators[i]->getName();
if (i < m_validators.size() - 1) desc += ", ";
}
return desc;
}
size_t getValidatorCount() const {
return m_validators.size();
}
};
}
namespace Output {
class OutputFormatter {
public:
virtual ~OutputFormatter() = default;
virtual std::string format(ResultType result) const = 0;
virtual std::string getName() const = 0;
virtual std::string getMimeType() const = 0;
};
class SimpleFormatter : public OutputFormatter {
public:
std::string format(ResultType result) const override {
LOCK_GLOBAL_MUTEX;
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[SimpleFormatter] Formatting result: " << result << std::endl;
#endif
return std::to_string(result);
}
std::string getName() const override { return "SimpleFormatter"; }
std::string getMimeType() const override { return "text/plain"; }
};
class DecoratedFormatter : public OutputFormatter {
private:
std::string m_prefix;
std::string m_suffix;
public:
DecoratedFormatter(const std::string& prefix = "", const std::string& suffix = "")
: m_prefix(prefix), m_suffix(suffix) {
#if ENABLE_VERBOSE_LOGGING
std::cerr << "[DecoratedFormatter] Created with prefix \"" << prefix << "\", suffix \"" << suffix << "\"" << std::endl;
#endif
}
std::string format(ResultType result) const override {
LOCK_GLOBAL_MUTEX;
return m_prefix + std::to_string(result) + m_suffix;
}
std::string getName() const override { return "DecoratedFormatter"; }
std::string getMimeType() const override { return "text/plain"; }
void setPrefix(const std::string& prefix) {
LOCK_GLOBAL_MUTEX;
m_prefix = prefix;
}
void setSuffix(const std::string& suffix) {
LOCK_GLOBAL_MUTEX;
m_suffix = suffix;
}
};
class JsonFormatter : public OutputFormatter {
public:
std::string format(ResultType result) const override {
LOCK_GLOBAL_MUTEX;
std::ostringstream oss;
oss << "{ \"result\": " << result
<< ", \"program_name\": \"" << kProgramName << "\""
<< ", \"version\": \"" << kProgramVersion << "\""
<< ", \"timestamp\": " << std::time(nullptr)
<< " }";
return oss.str();
}
std::string getName() const override { return "JsonFormatter"; }
std::string getMimeType() const override { return "application/json"; }
};
class XmlFormatter : public OutputFormatter {
public:
std::string format(ResultType result) const override {
LOCK_GLOBAL_MUTEX;
std::ostringstream oss;
oss << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl
<< "<result>" << std::endl
<< " <value>" << result << "</value>" << std::endl
<< " <program>" << kProgramName << "</program>" << std::endl
<< " <version>" << kProgramVersion << "</version>" << std::endl
<< " <timestamp>" << std::time(nullptr) << "</timestamp>" << std::endl
<< "</result>";
return oss.str();
}
std::string getName() const override { return "XmlFormatter"; }
std::string getMimeType() const override { return "application/xml"; }
};
class CsvFormatter : public OutputFormatter {
public:
std::string format(ResultType result) const override {
LOCK_GLOBAL_MUTEX;
std::ostringstream oss;
oss << "result,program,version,timestamp" << std::endl
<< result << "," << kProgramName << "," << kProgramVersion << "," << std::time(nullptr);
return oss.str();
}
std::string getName() const override { return "CsvFormatter"; }
std::string getMimeType() const override { return "text/csv"; }
};
class BinaryFormatter : public OutputFormatter {
public:
std::string format(ResultType result) const override {
LOCK_GLOBAL_MUTEX;
std::string binary_data;
binary_data.resize(sizeof(ResultType));
std::memcpy(&binary_data[0], &result, sizeof(ResultType));
return binary_data;
}
std::string getName() const override { return "BinaryFormatter"; }
std::string getMimeType() const override { return "application/octet-stream"; }
};
}
namespace Logging {
class Logger {
private:
LogLevel m_threshold;
std::ostream& m_outputStream;
std::string m_log_prefix;
public:
explicit Logger(LogLevel threshold = LogLevel::INFO, std::ostream& os = std::cerr, const std::string& prefix = "")
: m_threshold(threshold), m_outputStream(os), m_log_prefix(prefix) {}
template<typename... Args>
void log(LogLevel level, const Args&... args) const {
if (level >= m_threshold) {
LOCK_GLOBAL_MUTEX;
auto now = std::chrono::system_clock::now();
auto now_c = std::chrono::system_clock::to_time_t(now);
m_outputStream << "[" << std::put_time(std::localtime(&now_c), "%Y-%m-%d %H:%M:%S") << "] "
<< "[" << logLevelToString(level) << "] "
<< m_log_prefix;
(m_outputStream << ... << args) << std::endl;
std::ostringstream oss;
oss << "[" << std::put_time(std::localtime(&now_c), "%Y-%m-%d %H:%M:%S") << "] "
<< "[" << logLevelToString(level) << "] "
<< m_log_prefix;
(oss << ... << args);
g_dummy_logs.push_back(oss.str());
}
}
static std::string logLevelToString(LogLevel level) {
switch (level) {
case LogLevel::TRACE: return "TRACE";
case LogLevel::DEBUG: return "DEBUG";
case LogLevel::INFO: return "INFO";
case LogLevel::WARNING: return "WARNING";
case LogLevel::ERROR: return "ERROR";
case LogLevel::FATAL: return "FATAL";
default: return "UNKNOWN";
}
}
void setThreshold(LogLevel threshold) {
LOCK_GLOBAL_MUTEX;
m_threshold = threshold;
}
void setPrefix(const std::string& prefix) {
LOCK_GLOBAL_MUTEX;
m_log_prefix = prefix;
}
};
static Logger g_logger(LogLevel::TRACE, std::cerr, "[APlusB] ");
#define LOG_TRACE(...) g_logger.log(LogLevel::TRACE, __VA_ARGS__)
#define LOG_DEBUG(...) g_logger.log(LogLevel::DEBUG, __VA_ARGS__)
#define LOG_INFO(...) g_logger.log(LogLevel::INFO, __VA_ARGS__)
#define LOG_WARNING(...) g_logger.log(LogLevel::WARNING, __VA_ARGS__)
#define LOG_ERROR(...) g_logger.log(LogLevel::ERROR, __VA_ARGS__)
#define LOG_FATAL(...) g_logger.log(LogLevel::FATAL, __VA_ARGS__)
}
namespace Utility {
void nop() {
UNUSED(g_dummy_array);
UNUSED(g_dummy_deque);
UNUSED(g_dummy_list);
UNUSED(g_dummy_forward_list);
}
int random_number() {
static std::random_device rd;
static std::mt19937 gen(rd());
static std::uniform_int_distribution<> dis(0, 1000);
return dis(gen);
}
long long random_long_number() {
static std::random_device rd;
static std::mt19937_64 gen(rd());
static std::uniform_int_distribution<long long> dis(0, 1000000000000LL);
return dis(gen);
}
double random_double() {
static std::random_device rd;
static std::mt19937 gen(rd());
static std::uniform_real_distribution<> dis(0.0, 1.0);
return dis(gen);
}
std::string generate_random_string(size_t length = 10) {
static const char charset[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static std::random_device rd;
static std::mt19937 gen(rd());
static std::uniform_int_distribution<> dis(0, sizeof(charset) - 2);
std::string result;
result.reserve(length);
for (size_t i = 0; i < length; ++i) {
result += charset[dis(gen)];
}
return result;
}
void print_banner() {
std::cerr << R"(
╔═══════════════════════════════════════════════════════════════════╗
║ A+B SOLVER - ULTRA OVERKILL EDITION ║
║ (with MAXIMUM unnecessary complexity) ║
╠═══════════════════════════════════════════════════════════════════╣
║ Author: )" << kProgramAuthor << R"( ║
║ Version: )" << kProgramVersion << R"( ║
║ License: )" << kProgramLicense << R"( ║
║ Copyright: )" << kProgramCopyright << R"( ║
║ Build: )" << kProgramBuildDate << " " << kProgramBuildTime << R"( ║
╚═══════════════════════════════════════════════════════════════════╝
)" << std::endl;
}
void print_system_info() {
LOG_INFO("System information:");
LOG_INFO(" Integer size: ", sizeof(Integer), " bytes");
LOG_INFO(" Long long size: ", sizeof(LongInteger), " bytes");
LOG_INFO(" Float size: ", sizeof(FloatType), " bytes");
LOG_INFO(" Double size: ", sizeof(DoubleType), " bytes");
LOG_INFO(" Max int: ", MathConstants::MAX_INT);
LOG_INFO(" Min int: ", MathConstants::MIN_INT);
LOG_INFO(" Pi: ", MathConstants::PI);
LOG_INFO(" Euler's number: ", MathConstants::E);
LOG_INFO(" Golden ratio: ", MathConstants::GOLDEN_RATIO);
}
void simulate_heavy_computation(int iterations = MAX_ITERATIONS) {
LOG_DEBUG("Starting simulated heavy computation with ", iterations, " iterations");
long long dummy_sum = 0;
for (int i = 0; i < iterations; ++i) {
dummy_sum += factorial<10>();
dummy_sum += sum_variadic<1,2,3,4,5,6,7,8,9,10>();
UNUSED(dummy_sum);
}
LOG_DEBUG("Simulated heavy computation completed");
}
template<int N>
constexpr int factorial() {
return details::Factorial<N>::value;
}
template<int... Args>
constexpr int sum_variadic() {
return details::SumVariadic<Args...>::value;
}
std::string to_upper(const std::string& s) {
std::string result = s;
std::transform(result.begin(), result.end(), result.begin(), ::toupper);
return result;
}
std::string to_lower(const std::string& s) {
std::string result = s;
std::transform(result.begin(), result.end(), result.begin(), ::tolower);
return result;
}
std::vector<std::string> split_string(const std::string& s, char delimiter) {
std::vector<std::string> tokens;
std::string token;
std::istringstream tokenStream(s);
while (std::getline(tokenStream, token, delimiter)) {
tokens.push_back(token);
}
return tokens;
}
std::string join_strings(const std::vector<std::string>& tokens, const std::string& delimiter) {
std::ostringstream oss;
for (size_t i = 0; i < tokens.size(); ++i) {
if (i > 0) oss << delimiter;
oss << tokens[i];
}
return oss.str();
}
}
class Application {
private:
std::unique_ptr<Input::InputReader> m_reader;
std::unique_ptr<Parsing::Parser> m_parser;
std::unique_ptr<Validation::Validator> m_validator;
std::unique_ptr<Adder> m_adder;
std::unique_ptr<Output::OutputFormatter> m_formatter;
ApplicationConfig m_config;
PerformanceMetrics m_metrics;
std::vector<PerformanceMetrics> m_operation_metrics;
int m_run_count = 0;
public:
Application(std::unique_ptr<Input::InputReader> reader,
std::unique_ptr<Parsing::Parser> parser,
std::unique_ptr<Validation::Validator> validator,
std::unique_ptr<Adder> adder,
std::unique_ptr<Output::OutputFormatter> formatter,
const ApplicationConfig& config = ApplicationConfig())
: m_reader(std::move(reader))
, m_parser(std::move(parser))
, m_validator(std::move(validator))
, m_adder(std::move(adder))
, m_formatter(std::move(formatter))
, m_config(config) {
LOG_INFO("Application constructed with all dependencies.");
LOG_INFO("Input source: ", m_reader->getSourceName());
LOG_INFO("Parser: ", m_parser->getName());
LOG_INFO("Validator: ", m_validator->getName());
LOG_INFO("Adder strategy: ", m_adder->getCurrentStrategyName());
LOG_INFO("Output formatter: ", m_formatter->getName());
m_metrics.start_time = ChronoClock::now();
}
~Application() {
LOG_INFO("Application destroyed. Total runs: ", m_run_count);
m_metrics.end_time = ChronoClock::now();
m_metrics.total_duration = m_metrics.end_time - m_metrics.start_time;
LOG_INFO("Total application runtime: ", m_metrics.total_duration.count(), " ms");
LOG_INFO("Total operations performed: ", g_total_operations.load());
}
int run() {
int dummy1 = 0, dummy2 = 0, dummy3 = 0;
double
有帮助，赞一个