ZeroOSProject/BetterSTL
SHA256
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

统一命名

Browse Source
This commit is contained in:
ArchZer0
2026-08-16 19:15:19 +08:00
parent 9cb17262eb
commit 2a6c53d5bf
8 changed files with 451 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.clang-tidy
+145
View File
@@ -0,0 +1,145 @@
# Generated from CLion Inspection settings
---
Checks: '-*,
bugprone-argument-comment,
bugprone-assert-side-effect,
bugprone-bad-signal-to-kill-thread,
bugprone-branch-clone,
bugprone-copy-constructor-init,
bugprone-dangling-handle,
bugprone-dynamic-static-initializers,
bugprone-fold-init-type,
bugprone-forward-declaration-namespace,
bugprone-forwarding-reference-overload,
bugprone-inaccurate-erase,
bugprone-incorrect-roundings,
bugprone-integer-division,
bugprone-lambda-function-name,
bugprone-macro-parentheses,
bugprone-macro-repeated-side-effects,
bugprone-misplaced-operator-in-strlen-in-alloc,
bugprone-misplaced-pointer-arithmetic-in-alloc,
bugprone-misplaced-widening-cast,
bugprone-move-forwarding-reference,
bugprone-multiple-statement-macro,
bugprone-no-escape,
bugprone-parent-virtual-call,
bugprone-posix-return,
bugprone-reserved-identifier,
bugprone-sizeof-container,
bugprone-sizeof-expression,
bugprone-spuriously-wake-up-functions,
bugprone-string-constructor,
bugprone-string-integer-assignment,
bugprone-string-literal-with-embedded-nul,
bugprone-suspicious-enum-usage,
bugprone-suspicious-include,
bugprone-suspicious-memset-usage,
bugprone-suspicious-missing-comma,
bugprone-suspicious-semicolon,
bugprone-suspicious-string-compare,
bugprone-suspicious-memory-comparison,
bugprone-suspicious-realloc-usage,
bugprone-swapped-arguments,
bugprone-terminating-continue,
bugprone-throw-keyword-missing,
bugprone-too-small-loop-variable,
bugprone-undefined-memory-manipulation,
bugprone-undelegated-constructor,
bugprone-unhandled-self-assignment,
bugprone-unused-raii,
bugprone-unused-return-value,
bugprone-use-after-move,
bugprone-virtual-near-miss,
cert-dcl21-cpp,
cert-dcl58-cpp,
cert-err34-c,
cert-err52-cpp,
cert-err60-cpp,
cert-flp30-c,
cert-msc50-cpp,
cert-msc51-cpp,
cert-str34-c,
cppcoreguidelines-interfaces-global-init,
cppcoreguidelines-narrowing-conversions,
cppcoreguidelines-pro-type-member-init,
cppcoreguidelines-pro-type-static-cast-downcast,
cppcoreguidelines-slicing,
google-default-arguments,
google-runtime-operator,
hicpp-exception-baseclass,
hicpp-multiway-paths-covered,
misc-misplaced-const,
misc-new-delete-overloads,
misc-non-copyable-objects,
misc-throw-by-value-catch-by-reference,
misc-unconventional-assign-operator,
misc-uniqueptr-reset-release,
modernize-avoid-bind,
modernize-concat-nested-namespaces,
modernize-deprecated-headers,
modernize-deprecated-ios-base-aliases,
modernize-loop-convert,
modernize-make-shared,
modernize-make-unique,
modernize-pass-by-value,
modernize-raw-string-literal,
modernize-redundant-void-arg,
modernize-replace-auto-ptr,
modernize-replace-disallow-copy-and-assign-macro,
modernize-replace-random-shuffle,
modernize-return-braced-init-list,
modernize-shrink-to-fit,
modernize-unary-static-assert,
modernize-use-auto,
modernize-use-bool-literals,
modernize-use-emplace,
modernize-use-equals-default,
modernize-use-equals-delete,
modernize-use-nodiscard,
modernize-use-noexcept,
modernize-use-nullptr,
modernize-use-override,
modernize-use-transparent-functors,
modernize-use-uncaught-exceptions,
mpi-buffer-deref,
mpi-type-mismatch,
openmp-use-default-none,
performance-faster-string-find,
performance-for-range-copy,
performance-implicit-conversion-in-loop,
performance-inefficient-algorithm,
performance-inefficient-string-concatenation,
performance-inefficient-vector-operation,
performance-move-const-arg,
performance-move-constructor-init,
performance-no-automatic-move,
performance-noexcept-move-constructor,
performance-trivially-destructible,
performance-type-promotion-in-math-fn,
performance-unnecessary-copy-initialization,
performance-unnecessary-value-param,
portability-simd-intrinsics,
readability-avoid-const-params-in-decls,
readability-const-return-type,
readability-container-size-empty,
readability-convert-member-functions-to-static,
readability-delete-null-pointer,
readability-deleted-default,
readability-inconsistent-declaration-parameter-name,
readability-make-member-function-const,
readability-misleading-indentation,
readability-misplaced-array-index,
readability-non-const-parameter,
readability-redundant-control-flow,
readability-redundant-declaration,
readability-redundant-function-ptr-dereference,
readability-redundant-smartptr-get,
readability-redundant-string-cstr,
readability-redundant-string-init,
readability-simplify-subscript-expr,
readability-static-accessed-through-instance,
readability-static-definition-in-anonymous-namespace,
readability-string-compare,
readability-uniqueptr-delete-release,
readability-use-anyofallof'
include/bstl/big_decimal.hpp
+10 -10
View File
@@ -18,11 +18,11 @@ public:
BigDecimal(const BigDecimal& other) = default;
BigDecimal& operator=(const BigDecimal& other) = default;
bool isZero() const;
int sign() const;
int getScale() const;
BigInteger getUnscaledValue() const;
std::string toString() const;
[[nodiscard]] bool isZero() const;
[[nodiscard]] int sign() const;
[[nodiscard]] int getScale() const;
[[nodiscard]] BigInteger getUnscaledValue() const;
[[nodiscard]] std::string toString() const;
// Comparison operators
bool operator==(const BigDecimal& other) const;
@@ -59,14 +59,14 @@ public:
BigDecimal operator*(const BigDecimal& other) const;
BigDecimal operator/(const BigDecimal& other) const;
BigDecimal abs() const;
BigDecimal round(int scale) const;
[[nodiscard]] BigDecimal abs() const;
[[nodiscard]] BigDecimal round(int scale) const;
private:
BigInteger unscaledValue_; // 去掉小数点后的值
int scale_; // 小数点后的位数
BigInteger m_unscaledValue; // 去掉小数点后的值
int m_scale; // 小数点后的位数
static void alignScale(BigInteger& lhs, int& lhsScale,
static void m_alignScale(BigInteger& lhs, int& lhsScale,
BigInteger& rhs, int& rhsScale);
};
include/bstl/big_integer.hpp
+10 -10
View File
@@ -17,9 +17,9 @@ public:
BigInteger(const BigInteger& other) = default;
BigInteger& operator=(const BigInteger& other) = default;
bool isZero() const;
int sign() const;
std::string toString() const;
[[nodiscard]] bool isZero() const;
[[nodiscard]] int sign() const;
[[nodiscard]] std::string toString() const;
bool operator==(const BigInteger& other) const;
bool operator!=(const BigInteger& other) const;
@@ -55,14 +55,14 @@ public:
BigInteger operator/(const BigInteger& other) const;
private:
std::string digits_; // 无符号数字，从高位到低位
int sign_; // -1, 0, 1
std::string m_digits; // 无符号数字，从高位到低位
int m_sign; // -1, 0, 1
static std::string trimLeadingZeros(const std::string& value);
static int compareAbs(const std::string& a, const std::string& b);
static std::string addAbs(const std::string& a, const std::string& b);
static std::string subAbs(const std::string& a, const std::string& b);
static std::string mulAbs(const std::string& a, const std::string& b);
static std::string m_trimLeadingZeros(const std::string& value);
static int m_compareAbs(const std::string& a, const std::string& b);
static std::string m_addAbs(const std::string& a, const std::string& b);
static std::string m_subAbs(const std::string& a, const std::string& b);
static std::string m_mulAbs(const std::string& a, const std::string& b);
static std::string divAbs(const std::string& a, const std::string& b);
};
include/bstl/string.hpp
+36 -36
View File
@@ -11,69 +11,69 @@ namespace bstl {
class String {
public:
String();
String(const std::string& str);
String(std::string str);
String(const char* str);
String(const String& other) = default;
String& operator=(const String& other) = default;
// 获取标准字符串
std::string str() const;
const char* c_str() const;
size_t length() const;
size_t size() const;
bool empty() const;
[[nodiscard]] std::string str() const;
[[nodiscard]] const char* c_str() const;
[[nodiscard]] size_t length() const;
[[nodiscard]] size_t size() const;
[[nodiscard]] bool empty() const;
// 获取/修改字符
char at(size_t pos) const;
[[nodiscard]] char at(size_t pos) const;
char operator[](size_t pos) const;
char& operator[](size_t pos);
// 分割 - 按分隔符分割字符串
std::vector<String> split(const String& delimiter = " ") const;
[[nodiscard]] std::vector<String> split(const String& delimiter = " ") const;
// 连接 - 用分隔符连接多个字符串
static String join(const std::vector<String>& parts, const String& delimiter = "");
// 替换 - 替换第一个/所有匹配项
String replace(const String& oldStr, const String& newStr, int count = -1) const;
[[nodiscard]] String replace(const String& oldStr, const String& newStr, int count = -1) const;
// 大小写转换
String upper() const;
String lower() const;
String capitalize() const; // 首字母大写
String title() const; // 每个单词首字母大写
[[nodiscard]] String upper() const;
[[nodiscard]] String lower() const;
[[nodiscard]] String capitalize() const; // 首字母大写
[[nodiscard]] String title() const; // 每个单词首字母大写
// 判断函数
bool startswith(const String& prefix) const;
bool endswith(const String& suffix) const;
bool contains(const String& substring) const;
bool isdigit() const;
bool isalpha() const;
bool isalnum() const;
bool isspace() const;
bool isupper() const;
bool islower() const;
[[nodiscard]] bool startswith(const String& prefix) const;
[[nodiscard]] bool endswith(const String& suffix) const;
[[nodiscard]] bool contains(const String& substring) const;
[[nodiscard]] bool isdigit() const;
[[nodiscard]] bool isalpha() const;
[[nodiscard]] bool isalnum() const;
[[nodiscard]] bool isspace() const;
[[nodiscard]] bool isupper() const;
[[nodiscard]] bool islower() const;
// 查找和计数
int find(const String& substring, size_t start = 0) const;
int rfind(const String& substring) const; // 从后往前查找
int count(const String& substring) const;
[[nodiscard]] int find(const String& substring, size_t start = 0) const;
[[nodiscard]] int rfind(const String& substring) const; // 从后往前查找
[[nodiscard]] int count(const String& substring) const;
// 去除空格和其他字符
String strip() const; // 去除前后空格
String lstrip() const; // 去除前导空格
String rstrip() const; // 去除尾部空格
String strip(const String& chars) const; // 去除指定字符
[[nodiscard]] String strip() const; // 去除前后空格
[[nodiscard]] String lstrip() const; // 去除前导空格
[[nodiscard]] String rstrip() const; // 去除尾部空格
[[nodiscard]] String strip(const String& chars) const; // 去除指定字符
// 对齐和填充
String ljust(size_t width, char fillchar = ' ') const;
String rjust(size_t width, char fillchar = ' ') const;
String center(size_t width, char fillchar = ' ') const;
[[nodiscard]] String ljust(size_t width, char fillchar = ' ') const;
[[nodiscard]] String rjust(size_t width, char fillchar = ' ') const;
[[nodiscard]] String center(size_t width, char fillchar = ' ') const;
// 字符串转换
int toInt() const;
long long toLongLong() const;
double toDouble() const;
[[nodiscard]] int toInt() const;
[[nodiscard]] long long toLongLong() const;
[[nodiscard]] double toDouble() const;
// 运算符重载
String operator+(const String& other) const;
@@ -87,7 +87,7 @@ public:
bool operator>=(const String& other) const;
private:
std::string data_;
std::string m_data;
};
// 流运算符重载
src/big_decimal.cpp
+59 -59
View File
@@ -6,16 +6,16 @@
namespace bstl {
BigDecimal::BigDecimal() : unscaledValue_(0), scale_(0) {}
BigDecimal::BigDecimal() : m_unscaledValue(0), m_scale(0) {}
BigDecimal::BigDecimal(int value) : unscaledValue_(value), scale_(0) {}
BigDecimal::BigDecimal(int value) : m_unscaledValue(value), m_scale(0) {}
BigDecimal::BigDecimal(long long value) : unscaledValue_(value), scale_(0) {}
BigDecimal::BigDecimal(long long value) : m_unscaledValue(value), m_scale(0) {}
BigDecimal::BigDecimal(double value) : scale_(0) {
BigDecimal::BigDecimal(double value) : m_scale(0) {
if (value == 0.0) {
unscaledValue_ = 0;
scale_ = 0;
m_unscaledValue = 0;
m_scale = 0;
return;
}
@@ -26,7 +26,7 @@ BigDecimal::BigDecimal(double value) : scale_(0) {
*this = BigDecimal(oss.str());
}
BigDecimal::BigDecimal(const std::string& value) : unscaledValue_(0), scale_(0) {
BigDecimal::BigDecimal(const std::string& value) : m_unscaledValue(0), m_scale(0) {
if (value.empty()) {
return;
}
@@ -46,12 +46,12 @@ BigDecimal::BigDecimal(const std::string& value) : unscaledValue_(0), scale_(0)
// 查找小数点位置
size_t dotPos = text.find('.');
if (dotPos != std::string::npos) {
scale_ = text.size() - dotPos - 1;
m_scale = static_cast<int>(text.size() - dotPos - 1);
std::string digits = text.substr(0, dotPos) + text.substr(dotPos + 1);
unscaledValue_ = BigInteger(digits);
m_unscaledValue = BigInteger(digits);
} else {
scale_ = 0;
unscaledValue_ = BigInteger(text);
m_scale = 0;
m_unscaledValue = BigInteger(text);
}
}
@@ -59,26 +59,26 @@ BigDecimal::BigDecimal(const char* value)
: BigDecimal(value == nullptr ? std::string("0") : std::string(value)) {}
BigDecimal::BigDecimal(const BigInteger& unscaledValue, int scale)
: unscaledValue_(unscaledValue), scale_(scale) {
: m_unscaledValue(unscaledValue), m_scale(scale) {
if (scale < 0) {
throw std::invalid_argument("scale cannot be negative");
}
}
bool BigDecimal::isZero() const {
return unscaledValue_.isZero();
return m_unscaledValue.isZero();
}
int BigDecimal::sign() const {
return unscaledValue_.sign();
return m_unscaledValue.sign();
}
int BigDecimal::getScale() const {
return scale_;
return m_scale;
}
BigInteger BigDecimal::getUnscaledValue() const {
return unscaledValue_;
return m_unscaledValue;
}
std::string BigDecimal::toString() const {
@@ -86,7 +86,7 @@ std::string BigDecimal::toString() const {
return "0";
}
std::string digitStr = unscaledValue_.toString();
std::string digitStr = m_unscaledValue.toString();
// 处理符号
bool negative = false;
@@ -96,26 +96,26 @@ std::string BigDecimal::toString() const {
}
// 插入小数点
if (scale_ == 0) {
if (m_scale == 0) {
return (negative ? "-" : "") + digitStr;
}
if (static_cast<int>(digitStr.size()) <= scale_) {
if (static_cast<int>(digitStr.size()) <= m_scale) {
// 需要前置 "0."
std::string result = "0.";
for (int i = 0; i < scale_ - static_cast<int>(digitStr.size()); i++) {
for (int i = 0; i < m_scale - static_cast<int>(digitStr.size()); i++) {
result += "0";
}
result += digitStr;
return (negative ? "-" : "") + result;
}
int dotPos = digitStr.size() - scale_;
int dotPos = static_cast<int>(digitStr.size()) - m_scale;
std::string result = digitStr.substr(0, dotPos) + "." + digitStr.substr(dotPos);
return (negative ? "-" : "") + result;
}
void BigDecimal::alignScale(BigInteger& lhs, int& lhsScale,
void BigDecimal::m_alignScale(BigInteger& lhs, int& lhsScale,
BigInteger& rhs, int& rhsScale) {
if (lhsScale < rhsScale) {
// 左边需要扩大
@@ -134,11 +134,11 @@ void BigDecimal::alignScale(BigInteger& lhs, int& lhsScale,
bool BigDecimal::operator==(const BigDecimal& other) const {
if (isZero() && other.isZero()) return true;
BigInteger lhs = unscaledValue_;
BigInteger rhs = other.unscaledValue_;
int lhsScale = scale_;
int rhsScale = other.scale_;
alignScale(lhs, lhsScale, rhs, rhsScale);
BigInteger lhs = m_unscaledValue;
BigInteger rhs = other.m_unscaledValue;
int lhsScale = m_scale;
int rhsScale = other.m_scale;
m_alignScale(lhs, lhsScale, rhs, rhsScale);
return lhs == rhs;
}
@@ -147,17 +147,17 @@ bool BigDecimal::operator!=(const BigDecimal& other) const {
}
bool BigDecimal::operator<(const BigDecimal& other) const {
if (unscaledValue_.sign() != other.unscaledValue_.sign()) {
return unscaledValue_.sign() < other.unscaledValue_.sign();
if (m_unscaledValue.sign() != other.m_unscaledValue.sign()) {
return m_unscaledValue.sign() < other.m_unscaledValue.sign();
}
BigInteger lhs = unscaledValue_;
BigInteger rhs = other.unscaledValue_;
int lhsScale = scale_;
int rhsScale = other.scale_;
alignScale(lhs, lhsScale, rhs, rhsScale);
BigInteger lhs = m_unscaledValue;
BigInteger rhs = other.m_unscaledValue;
int lhsScale = m_scale;
int rhsScale = other.m_scale;
m_alignScale(lhs, lhsScale, rhs, rhsScale);
if (unscaledValue_.sign() >= 0) {
if (m_unscaledValue.sign() >= 0) {
return lhs < rhs;
} else {
return lhs > rhs;
@@ -230,9 +230,9 @@ BigDecimal BigDecimal::operator+() const {
BigDecimal BigDecimal::operator-() const {
if (isZero()) {
return BigDecimal(0);
return {0};
}
return BigDecimal(-unscaledValue_, scale_);
return {-m_unscaledValue, m_scale};
}
BigDecimal& BigDecimal::operator+=(const BigDecimal& other) {
@@ -259,13 +259,13 @@ BigDecimal BigDecimal::operator+(const BigDecimal& other) const {
if (isZero()) return other;
if (other.isZero()) return *this;
BigInteger lhs = unscaledValue_;
BigInteger rhs = other.unscaledValue_;
int lhsScale = scale_;
int rhsScale = other.scale_;
alignScale(lhs, lhsScale, rhs, rhsScale);
BigInteger lhs = m_unscaledValue;
BigInteger rhs = other.m_unscaledValue;
int lhsScale = m_scale;
int rhsScale = other.m_scale;
m_alignScale(lhs, lhsScale, rhs, rhsScale);
return BigDecimal(lhs + rhs, lhsScale);
return {lhs + rhs, lhsScale};
}
BigDecimal BigDecimal::operator-(const BigDecimal& other) const {
@@ -274,13 +274,13 @@ BigDecimal BigDecimal::operator-(const BigDecimal& other) const {
BigDecimal BigDecimal::operator*(const BigDecimal& other) const {
if (isZero() || other.isZero()) {
return BigDecimal(0);
return {0};
}
BigInteger result = unscaledValue_ * other.unscaledValue_;
int resultScale = scale_ + other.scale_;
BigInteger result = m_unscaledValue * other.m_unscaledValue;
int resultScale = m_scale + other.m_scale;
return BigDecimal(result, resultScale);
return {result, resultScale};
}
BigDecimal BigDecimal::operator/(const BigDecimal& other) const {
@@ -289,14 +289,14 @@ BigDecimal BigDecimal::operator/(const BigDecimal& other) const {
}
if (isZero()) {
return BigDecimal(0);
return {0};
}
// 先对齐 scale，然后做整数除法
BigInteger lhs = unscaledValue_;
BigInteger rhs = other.unscaledValue_;
int lhsScale = scale_;
int rhsScale = other.scale_;
BigInteger lhs = m_unscaledValue;
BigInteger rhs = other.m_unscaledValue;
int lhsScale = m_scale;
int rhsScale = other.m_scale;
// 使用更高的精度进行除法
// 乘以 10^precision 来获得更多的精度
@@ -308,14 +308,14 @@ BigDecimal BigDecimal::operator/(const BigDecimal& other) const {
BigInteger quotient = lhs / rhs;
int resultScale = lhsScale - rhsScale + precision;
return BigDecimal(quotient, resultScale);
return {quotient, resultScale};
}
BigDecimal BigDecimal::abs() const {
if (unscaledValue_.sign() >= 0) {
if (m_unscaledValue.sign() >= 0) {
return *this;
}
return BigDecimal(-unscaledValue_, scale_);
return {-m_unscaledValue, m_scale};
}
BigDecimal BigDecimal::round(int scale) const {
@@ -323,19 +323,19 @@ BigDecimal BigDecimal::round(int scale) const {
throw std::invalid_argument("scale cannot be negative");
}
if (scale >= scale_) {
if (scale >= m_scale) {
return *this;
}
// 简单实现：直接截断到指定小数位数
int diff = scale_ - scale;
int diff = m_scale - scale;
BigInteger divisor = BigInteger(10);
for (int i = 1; i < diff; i++) {
divisor = divisor * BigInteger(10);
}
BigInteger rounded = unscaledValue_ / divisor;
return BigDecimal(rounded, scale);
BigInteger rounded = m_unscaledValue / divisor;
return {rounded, scale};
}
std::ostream& operator<<(std::ostream& os, const BigDecimal& bd) {
src/big_integer.cpp
+84 -84
View File
@@ -7,7 +7,7 @@
namespace bstl {
std::string BigInteger::trimLeadingZeros(const std::string& value) {
std::string BigInteger::m_trimLeadingZeros(const std::string& value) {
size_t pos = 0;
while (pos < value.size() - 1 && value[pos] == '0') {
pos++;
@@ -15,16 +15,16 @@ std::string BigInteger::trimLeadingZeros(const std::string& value) {
return value.substr(pos);
}
int BigInteger::compareAbs(const std::string& a, const std::string& b) {
std::string ta = trimLeadingZeros(a);
std::string tb = trimLeadingZeros(b);
int BigInteger::m_compareAbs(const std::string& a, const std::string& b) {
std::string ta = m_trimLeadingZeros(a);
std::string tb = m_trimLeadingZeros(b);
if (ta.size() != tb.size()) {
return ta.size() < tb.size() ? -1 : 1;
}
return ta.compare(tb) < 0 ? -1 : (ta.compare(tb) > 0 ? 1 : 0);
}
std::string BigInteger::addAbs(const std::string& a, const std::string& b) {
std::string BigInteger::m_addAbs(const std::string& a, const std::string& b) {
std::string result;
int carry = 0;
int i = static_cast<int>(a.size()) - 1;
@@ -33,17 +33,17 @@ std::string BigInteger::addAbs(const std::string& a, const std::string& b) {
int sum = carry;
if (i >= 0) sum += a[i--] - '0';
if (j >= 0) sum += b[j--] - '0';
result = char('0' + sum % 10) + result;
result.insert(result.begin(), static_cast<char>('0' + sum % 10));
carry = sum / 10;
}
return result;
}
std::string BigInteger::subAbs(const std::string& a, const std::string& b) {
std::string ta = trimLeadingZeros(a);
std::string tb = trimLeadingZeros(b);
if (compareAbs(ta, tb) < 0) {
return subAbs(tb, ta);
std::string BigInteger::m_subAbs(const std::string& a, const std::string& b) {
std::string ta = m_trimLeadingZeros(a);
std::string tb = m_trimLeadingZeros(b);
if (m_compareAbs(ta, tb) < 0) {
return m_subAbs(tb, ta);
}
std::string result;
int borrow = 0;
@@ -60,14 +60,14 @@ std::string BigInteger::subAbs(const std::string& a, const std::string& b) {
} else {
borrow = 0;
}
result = char('0' + diff) + result;
result.insert(result.begin(), static_cast<char>('0' + diff));
}
return trimLeadingZeros(result);
return m_trimLeadingZeros(result);
}
std::string BigInteger::mulAbs(const std::string& a, const std::string& b) {
std::string ta = trimLeadingZeros(a);
std::string tb = trimLeadingZeros(b);
std::string BigInteger::m_mulAbs(const std::string& a, const std::string& b) {
std::string ta = m_trimLeadingZeros(a);
std::string tb = m_trimLeadingZeros(b);
if (ta == "0" || tb == "0") return "0";
std::vector<int> product(ta.size() + tb.size(), 0);
@@ -79,9 +79,9 @@ std::string BigInteger::mulAbs(const std::string& a, const std::string& b) {
}
int carry = 0;
for (size_t i = 0; i < product.size(); i++) {
int sum = product[i] + carry;
product[i] = sum % 10;
for (int & i : product) {
int sum = i + carry;
i = sum % 10;
carry = sum / 10;
}
@@ -89,16 +89,16 @@ std::string BigInteger::mulAbs(const std::string& a, const std::string& b) {
for (int i = static_cast<int>(product.size()) - 1; i >= 0; i--) {
result += char('0' + product[i]);
}
return trimLeadingZeros(result);
return m_trimLeadingZeros(result);
}
std::string BigInteger::divAbs(const std::string& a, const std::string& b) {
std::string tb = trimLeadingZeros(b);
std::string tb = m_trimLeadingZeros(b);
if (tb == "0") {
throw std::invalid_argument("division by zero");
}
std::string ta = trimLeadingZeros(a);
if (compareAbs(ta, tb) < 0) {
std::string ta = m_trimLeadingZeros(a);
if (m_compareAbs(ta, tb) < 0) {
return "0";
}
@@ -106,86 +106,86 @@ std::string BigInteger::divAbs(const std::string& a, const std::string& b) {
std::string current;
for (char digit : ta) {
current += digit;
current = trimLeadingZeros(current);
current = m_trimLeadingZeros(current);
int count = 0;
while (compareAbs(current, tb) >= 0) {
current = subAbs(current, tb);
while (m_compareAbs(current, tb) >= 0) {
current = m_subAbs(current, tb);
count++;
}
quotient += char('0' + count);
}
return trimLeadingZeros(quotient);
return m_trimLeadingZeros(quotient);
}
BigInteger::BigInteger() : digits_("0"), sign_(0) {}
BigInteger::BigInteger() : m_digits("0"), m_sign(0) {}
BigInteger::BigInteger(int value) : digits_("0"), sign_(1) {
BigInteger::BigInteger(int value) : m_digits("0"), m_sign(1) {
if (value == 0) {
digits_ = "0";
sign_ = 0;
m_digits = "0";
m_sign = 0;
return;
}
if (value < 0) {
sign_ = -1;
m_sign = -1;
value = -value;
}
digits_.clear();
m_digits.clear();
while (value > 0) {
digits_ = char('0' + value % 10) + digits_;
m_digits = char('0' + value % 10) + m_digits;
value /= 10;
}
}
BigInteger::BigInteger(long long value) : digits_("0"), sign_(1) {
BigInteger::BigInteger(long long value) : m_digits("0"), m_sign(1) {
if (value == 0) {
digits_ = "0";
sign_ = 0;
m_digits = "0";
m_sign = 0;
return;
}
if (value < 0) {
sign_ = -1;
m_sign = -1;
value = -value;
}
digits_.clear();
m_digits.clear();
while (value > 0) {
digits_ = char('0' + value % 10) + digits_;
m_digits = char('0' + value % 10) + m_digits;
value /= 10;
}
}
BigInteger::BigInteger(unsigned long long value) : digits_("0"), sign_(1) {
BigInteger::BigInteger(unsigned long long value) : m_digits("0"), m_sign(1) {
if (value == 0) {
digits_ = "0";
sign_ = 0;
m_digits = "0";
m_sign = 0;
return;
}
digits_.clear();
m_digits.clear();
while (value > 0) {
digits_ = char('0' + value % 10) + digits_;
m_digits = char('0' + value % 10) + m_digits;
value /= 10;
}
}
BigInteger::BigInteger(const std::string& value) : digits_("0"), sign_(1) {
BigInteger::BigInteger(const std::string& value) : m_digits("0"), m_sign(1) {
if (value.empty()) {
digits_ = "0";
sign_ = 0;
m_digits = "0";
m_sign = 0;
return;
}
std::string text = value;
sign_ = 1;
m_sign = 1;
if (text[0] == '-') {
sign_ = -1;
m_sign = -1;
text = text.substr(1);
} else if (text[0] == '+') {
text = text.substr(1);
}
if (text.empty()) {
digits_ = "0";
sign_ = 0;
m_digits = "0";
m_sign = 0;
return;
}
@@ -195,9 +195,9 @@ BigInteger::BigInteger(const std::string& value) : digits_("0"), sign_(1) {
}
}
digits_ = trimLeadingZeros(text);
if (digits_ == "0") {
sign_ = 0;
m_digits = m_trimLeadingZeros(text);
if (m_digits == "0") {
m_sign = 0;
}
}
@@ -205,21 +205,21 @@ BigInteger::BigInteger(const char* value)
: BigInteger(value == nullptr ? std::string("0") : std::string(value)) {}
bool BigInteger::isZero() const {
return sign_ == 0 || digits_ == "0";
return m_sign == 0 || m_digits == "0";
}
int BigInteger::sign() const {
return isZero() ? 0 : sign_;
return isZero() ? 0 : m_sign;
}
std::string BigInteger::toString() const {
if (isZero()) return "0";
return (sign_ < 0 ? "-" : "") + digits_;
return (m_sign < 0 ? "-" : "") + m_digits;
}
bool BigInteger::operator==(const BigInteger& other) const {
if (isZero() && other.isZero()) return true;
return sign_ == other.sign_ && digits_ == other.digits_;
return m_sign == other.m_sign && m_digits == other.m_digits;
}
bool BigInteger::operator!=(const BigInteger& other) const {
@@ -227,10 +227,10 @@ bool BigInteger::operator!=(const BigInteger& other) const {
}
bool BigInteger::operator<(const BigInteger& other) const {
if (sign_ != other.sign_) return sign_ < other.sign_;
if (sign_ == 0) return false;
int cmp = compareAbs(digits_, other.digits_);
return sign_ > 0 ? cmp < 0 : cmp > 0;
if (m_sign != other.m_sign) return m_sign < other.m_sign;
if (m_sign == 0) return false;
int cmp = m_compareAbs(m_digits, other.m_digits);
return m_sign > 0 ? cmp < 0 : cmp > 0;
}
bool BigInteger::operator>(const BigInteger& other) const {
@@ -298,9 +298,9 @@ BigInteger BigInteger::operator+() const {
}
BigInteger BigInteger::operator-() const {
if (isZero()) return BigInteger(0);
if (isZero()) return {0};
BigInteger result(*this);
result.sign_ = -result.sign_;
result.m_sign = -result.m_sign;
return result;
}
@@ -329,23 +329,23 @@ BigInteger BigInteger::operator+(const BigInteger& other) const {
if (other.isZero()) return *this;
BigInteger result;
if (sign_ == other.sign_) {
result.digits_ = addAbs(digits_, other.digits_);
result.sign_ = sign_;
if (m_sign == other.m_sign) {
result.m_digits = m_addAbs(m_digits, other.m_digits);
result.m_sign = m_sign;
} else {
int cmp = compareAbs(digits_, other.digits_);
int cmp = m_compareAbs(m_digits, other.m_digits);
if (cmp == 0) {
result.digits_ = "0";
result.sign_ = 0;
result.m_digits = "0";
result.m_sign = 0;
} else if (cmp > 0) {
result.digits_ = subAbs(digits_, other.digits_);
result.sign_ = sign_;
result.m_digits = m_subAbs(m_digits, other.m_digits);
result.m_sign = m_sign;
} else {
result.digits_ = subAbs(other.digits_, digits_);
result.sign_ = other.sign_;
result.m_digits = m_subAbs(other.m_digits, m_digits);
result.m_sign = other.m_sign;
}
}
if (result.digits_ == "0") result.sign_ = 0;
if (result.m_digits == "0") result.m_sign = 0;
return result;
}
@@ -354,11 +354,11 @@ BigInteger BigInteger::operator-(const BigInteger& other) const {
}
BigInteger BigInteger::operator*(const BigInteger& other) const {
if (isZero() || other.isZero()) return BigInteger(0);
if (isZero() || other.isZero()) return {0};
BigInteger result;
result.digits_ = mulAbs(digits_, other.digits_);
result.sign_ = (sign_ * other.sign_);
if (result.digits_ == "0") result.sign_ = 0;
result.m_digits = m_mulAbs(m_digits, other.m_digits);
result.m_sign = (m_sign * other.m_sign);
if (result.m_digits == "0") result.m_sign = 0;
return result;
}
@@ -366,11 +366,11 @@ BigInteger BigInteger::operator/(const BigInteger& other) const {
if (other.isZero()) {
throw std::invalid_argument("division by zero");
}
if (isZero()) return BigInteger(0);
if (isZero()) return {0};
BigInteger result;
result.digits_ = divAbs(digits_, other.digits_);
result.sign_ = (sign_ * other.sign_);
if (result.digits_ == "0") result.sign_ = 0;
result.m_digits = divAbs(m_digits, other.m_digits);
result.m_sign = (m_sign * other.m_sign);
if (result.m_digits == "0") result.m_sign = 0;
return result;
}
src/string.cpp
+100 -115
View File
@@ -2,54 +2,55 @@
#include <sstream>
#include <stdexcept>
#include <utility>
namespace bstl {
String::String() : data_("") {}
String::String() = default;
String::String(const std::string& str) : data_(str) {}
String::String(std::string str) : m_data(std::move(str)) {}
String::String(const char* str) : data_(str == nullptr ? "" : str) {}
String::String(const char* str) : m_data(str == nullptr ? "" : str) {}
std::string String::str() const {
return data_;
return m_data;
}
const char* String::c_str() const {
return data_.c_str();
return m_data.c_str();
}
size_t String::length() const {
return data_.length();
return m_data.length();
}
size_t String::size() const {
return data_.size();
return m_data.size();
}
bool String::empty() const {
return data_.empty();
return m_data.empty();
}
char String::at(size_t pos) const {
if (pos >= data_.size()) {
if (pos >= m_data.size()) {
throw std::out_of_range("String::at: index out of range");
}
return data_[pos];
return m_data[pos];
}
char String::operator[](size_t pos) const {
return data_[pos];
return m_data[pos];
}
char& String::operator[](size_t pos) {
return data_[pos];
return m_data[pos];
}
std::vector<String> String::split(const String& delimiter) const {
std::vector<String> result;
if (data_.empty()) {
if (m_data.empty()) {
return result;
}
@@ -61,25 +62,25 @@ std::vector<String> String::split(const String& delimiter) const {
size_t start = 0;
size_t pos = 0;
while ((pos = data_.find(delimiter.data_, start)) != std::string::npos) {
result.push_back(String(data_.substr(start, pos - start)));
while ((pos = m_data.find(delimiter.m_data, start)) != std::string::npos) {
result.emplace_back(m_data.substr(start, pos - start));
start = pos + delimiter.size();
}
result.push_back(String(data_.substr(start)));
result.emplace_back(m_data.substr(start));
return result;
}
String String::join(const std::vector<String>& parts, const String& delimiter) {
if (parts.empty()) {
return String("");
return {""};
}
std::string result = parts[0].str();
for (size_t i = 1; i < parts.size(); i++) {
result += delimiter.str() + parts[i].str();
}
return String(result);
return {result};
}
String String::replace(const String& oldStr, const String& newStr, int count) const {
@@ -87,140 +88,124 @@ String String::replace(const String& oldStr, const String& newStr, int count) co
return *this;
}
std::string result = data_;
std::string result = m_data;
size_t pos = 0;
int replaced = 0;
while ((pos = result.find(oldStr.data_, pos)) != std::string::npos && (count < 0 || replaced < count)) {
while ((pos = result.find(oldStr.m_data, pos)) != std::string::npos && (count < 0 || replaced < count)) {
result.replace(pos, oldStr.size(), newStr.str());
pos += newStr.size();
replaced++;
}
return String(result);
return {result};
}
String String::upper() const {
std::string result = data_;
std::string result = m_data;
std::transform(result.begin(), result.end(), result.begin(),
[](unsigned char c) { return std::toupper(c); });
return String(result);
return {result};
}
String String::lower() const {
std::string result = data_;
std::string result = m_data;
std::transform(result.begin(), result.end(), result.begin(),
[](unsigned char c) { return std::tolower(c); });
return String(result);
return {result};
}
String String::capitalize() const {
if (data_.empty()) {
if (m_data.empty()) {
return *this;
}
std::string result = data_;
result[0] = std::toupper(static_cast<unsigned char>(result[0]));
std::string result = m_data;
result[0] = static_cast<char>(std::toupper(static_cast<unsigned char>(result[0])));
for (size_t i = 1; i < result.size(); i++) {
result[i] = std::tolower(static_cast<unsigned char>(result[i]));
result[i] = static_cast<char>(std::tolower(static_cast<unsigned char>(result[i])));
}
return String(result);
return {result};
}
String String::title() const {
std::string result = data_;
std::string result = m_data;
bool newWord = true;
for (size_t i = 0; i < result.size(); i++) {
if (std::isspace(static_cast<unsigned char>(result[i]))) {
for (char & i : result) {
if (std::isspace(static_cast<unsigned char>(i))) {
newWord = true;
} else {
if (newWord) {
result[i] = std::toupper(static_cast<unsigned char>(result[i]));
i = static_cast<char>(std::toupper(static_cast<unsigned char>(i)));
newWord = false;
} else {
result[i] = std::tolower(static_cast<unsigned char>(result[i]));
i = static_cast<char>(std::tolower(static_cast<unsigned char>(i)));
}
}
}
return String(result);
return {result};
}
bool String::startswith(const String& prefix) const {
if (prefix.size() > data_.size()) {
if (prefix.size() > m_data.size()) {
return false;
}
return data_.compare(0, prefix.size(), prefix.data_) == 0;
return m_data.compare(0, prefix.size(), prefix.m_data) == 0;
}
bool String::endswith(const String& suffix) const {
if (suffix.size() > data_.size()) {
if (suffix.size() > m_data.size()) {
return false;
}
return data_.compare(data_.size() - suffix.size(), suffix.size(), suffix.data_) == 0;
return m_data.compare(m_data.size() - suffix.size(), suffix.size(), suffix.m_data) == 0;
}
bool String::contains(const String& substring) const {
return data_.find(substring.data_) != std::string::npos;
return m_data.find(substring.m_data) != std::string::npos;
}
bool String::isdigit() const {
if (data_.empty()) return false;
for (unsigned char c : data_) {
if (!std::isdigit(c)) return false;
}
return true;
return !m_data.empty() &&
std::all_of(m_data.begin(), m_data.end(),
[](unsigned char c) { return std::isdigit(c) != 0; });
}
bool String::isalpha() const {
if (data_.empty()) return false;
for (unsigned char c : data_) {
if (!std::isalpha(c)) return false;
}
return true;
return !m_data.empty() &&
std::all_of(m_data.begin(), m_data.end(),
[](unsigned char c) { return std::isalpha(c) != 0; });
}
bool String::isalnum() const {
if (data_.empty()) return false;
for (unsigned char c : data_) {
if (!std::isalnum(c)) return false;
}
return true;
return !m_data.empty() &&
std::all_of(m_data.begin(), m_data.end(),
[](unsigned char c) { return std::isalnum(c) != 0; });
}
bool String::isspace() const {
if (data_.empty()) return false;
for (unsigned char c : data_) {
if (!std::isspace(c)) return false;
}
return true;
return !m_data.empty() &&
std::all_of(m_data.begin(), m_data.end(),
[](unsigned char c) { return std::isspace(c) != 0; });
}
bool String::isupper() const {
if (data_.empty()) return false;
for (unsigned char c : data_) {
if (std::isalpha(c) && !std::isupper(c)) {
return false;
}
}
return true;
return !m_data.empty() &&
std::all_of(m_data.begin(), m_data.end(),
[](unsigned char c) { return !std::isalpha(c) || std::isupper(c) != 0; });
}
bool String::islower() const {
if (data_.empty()) return false;
for (unsigned char c : data_) {
if (std::isalpha(c) && !std::islower(c)) {
return false;
}
}
return true;
return !m_data.empty() &&
std::all_of(m_data.begin(), m_data.end(),
[](unsigned char c) { return !std::isalpha(c) || std::islower(c) != 0; });
}
int String::find(const String& substring, size_t start) const {
size_t pos = data_.find(substring.data_, start);
size_t pos = m_data.find(substring.m_data, start);
return pos == std::string::npos ? -1 : static_cast<int>(pos);
}
int String::rfind(const String& substring) const {
size_t pos = data_.rfind(substring.data_);
size_t pos = m_data.rfind(substring.m_data);
return pos == std::string::npos ? -1 : static_cast<int>(pos);
}
@@ -228,7 +213,7 @@ int String::count(const String& substring) const {
if (substring.empty()) return 0;
int count = 0;
size_t pos = 0;
while ((pos = data_.find(substring.data_, pos)) != std::string::npos) {
while ((pos = m_data.find(substring.m_data, pos)) != std::string::npos) {
count++;
pos += substring.size();
}
@@ -237,126 +222,126 @@ int String::count(const String& substring) const {
String String::strip() const {
size_t start = 0;
size_t end = data_.size();
size_t end = m_data.size();
while (start < end && std::isspace(static_cast<unsigned char>(data_[start]))) {
while (start < end && std::isspace(static_cast<unsigned char>(m_data[start]))) {
start++;
}
while (end > start && std::isspace(static_cast<unsigned char>(data_[end - 1]))) {
while (end > start && std::isspace(static_cast<unsigned char>(m_data[end - 1]))) {
end--;
}
return String(data_.substr(start, end - start));
return {m_data.substr(start, end - start)};
}
String String::lstrip() const {
size_t start = 0;
while (start < data_.size() && std::isspace(static_cast<unsigned char>(data_[start]))) {
while (start < m_data.size() && std::isspace(static_cast<unsigned char>(m_data[start]))) {
start++;
}
return String(data_.substr(start));
return {m_data.substr(start)};
}
String String::rstrip() const {
size_t end = data_.size();
while (end > 0 && std::isspace(static_cast<unsigned char>(data_[end - 1]))) {
size_t end = m_data.size();
while (end > 0 && std::isspace(static_cast<unsigned char>(m_data[end - 1]))) {
end--;
}
return String(data_.substr(0, end));
return {m_data.substr(0, end)};
}
String String::strip(const String& chars) const {
size_t start = 0;
size_t end = data_.size();
size_t end = m_data.size();
while (start < end && chars.data_.find(data_[start]) != std::string::npos) {
while (start < end && chars.m_data.find(m_data[start]) != std::string::npos) {
start++;
}
while (end > start && chars.data_.find(data_[end - 1]) != std::string::npos) {
while (end > start && chars.m_data.find(m_data[end - 1]) != std::string::npos) {
end--;
}
return String(data_.substr(start, end - start));
return {m_data.substr(start, end - start)};
}
String String::ljust(size_t width, char fillchar) const {
if (data_.size() >= width) {
if (m_data.size() >= width) {
return *this;
}
std::string result = data_;
result.append(width - data_.size(), fillchar);
return String(result);
std::string result = m_data;
result.append(width - m_data.size(), fillchar);
return {result};
}
String String::rjust(size_t width, char fillchar) const {
if (data_.size() >= width) {
if (m_data.size() >= width) {
return *this;
}
std::string result(width - data_.size(), fillchar);
result.append(data_);
return String(result);
std::string result(width - m_data.size(), fillchar);
result.append(m_data);
return {result};
}
String String::center(size_t width, char fillchar) const {
if (data_.size() >= width) {
if (m_data.size() >= width) {
return *this;
}
size_t totalPad = width - data_.size();
size_t totalPad = width - m_data.size();
size_t leftPad = totalPad / 2;
size_t rightPad = totalPad - leftPad;
std::string result(leftPad, fillchar);
result.append(data_);
result.append(m_data);
result.append(rightPad, fillchar);
return String(result);
return {result};
}
int String::toInt() const {
return std::stoi(data_);
return std::stoi(m_data);
}
long long String::toLongLong() const {
return std::stoll(data_);
return std::stoll(m_data);
}
double String::toDouble() const {
return std::stod(data_);
return std::stod(m_data);
}
String String::operator+(const String& other) const {
return String(data_ + other.data_);
return {m_data + other.m_data};
}
String String::operator+(const char* str) const {
return String(data_ + (str == nullptr ? "" : str));
return {m_data + (str == nullptr ? "" : str)};
}
String& String::operator+=(const String& other) {
data_ += other.data_;
m_data += other.m_data;
return *this;
}
bool String::operator==(const String& other) const {
return data_ == other.data_;
return m_data == other.m_data;
}
bool String::operator!=(const String& other) const {
return data_ != other.data_;
return m_data != other.m_data;
}
bool String::operator<(const String& other) const {
return data_ < other.data_;
return m_data < other.m_data;
}
bool String::operator>(const String& other) const {
return data_ > other.data_;
return m_data > other.m_data;
}
bool String::operator<=(const String& other) const {
return data_ <= other.data_;
return m_data <= other.m_data;
}
bool String::operator>=(const String& other) const {
return data_ >= other.data_;
return m_data >= other.m_data;
}
std::ostream& operator<<(std::ostream& os, const String& str) {
tests/big_integer_test.cpp
+7 -7
View File
@@ -7,19 +7,19 @@
int main() {
using bstl::BigInteger;
BigInteger a("12345678901234567890");
BigInteger b("98765432109876543210");
BigInteger c = a + b;
BigInteger d = b - a;
BigInteger e = a * BigInteger("2");
BigInteger f = BigInteger("100000000000000000000000") / BigInteger("1000000000000000000");
const BigInteger a("12345678901234567890");
const BigInteger b("98765432109876543210");
const BigInteger c = a + b;
const BigInteger d = b - a;
const BigInteger e = a * BigInteger("2");
const BigInteger f = BigInteger("100000000000000000000000") / BigInteger("1000000000000000000");
assert(c.toString() == "111111111011111111100");
assert(d.toString() == "86419753208641975320");
assert(e.toString() == "24691357802469135780");
assert(f.toString() == "100000");
BigInteger zero("0");
const BigInteger zero("0");
assert((a == a) == true);
assert((a != b) == true);
assert((zero == 0) == true);