C++实现一个带溢出检测的数值类

于 2022-10-04 09:59:59 发布
阅读量265 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a4364634611/article/details/127159562
版权 
export module number;

import<concepts>;
import<exception>;
import<vector>;
import<initializer_list>;
import<string>;
import<limits>;
import<format>;
import<algorithm>;
import<cmath>;
import<type_traits>;
import<typeinfo>;

export namespace myNum {

	//Custom numeric overflow exception
	struct NumOverflow :std::exception
	{
		NumOverflow(const std::string& s) :exception(s.data()) {}
	};

	//Specifies that constraints can only be integer and floating point
	template < class T >
	concept number = std::is_arithmetic_v<T>;

	template<number T>
	class Number {
	public:

		constexpr static T max = std::numeric_limits<T>::max();

		constexpr static T min = std::numeric_limits<T>::min();

		constexpr Number(T v)noexcept :_value{ v } {}

		constexpr Number()noexcept = default;

		constexpr Number(Number&& v)noexcept {
			this->_value = v.GetValue();
		}

		constexpr Number(const Number& v)noexcept = default;

		~Number() = default;

		template<typename T2>
		constexpr Number<T>& operator =(const Number<T2>& v)noexcept {
			this->_value = v.GetValue();
			return *this;
		}

		constexpr Number& operator=(const Number& v)noexcept = default;

		template<typename T2>
		constexpr Number<T>& operator =(Number<T2>&& v)noexcept {
			this->_value = v.GetValue();
			return *this;
		}

		constexpr Number& operator++()noexcept
		{
			this->_value++;
			return *this;
		}

		constexpr Number operator++(int)noexcept
		{
			auto old = *this;
			operator++();
			return old;
		}

		constexpr Number& operator--()noexcept
		{
			this->_value--;
			return *this;
		}

		constexpr Number operator--(int)noexcept
		{
			auto old = *this;
			operator--();
			return old;
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator +(const Number<T2>& v)const {
			using Type = std::common_type_t<T, T2>;
			auto max = std::max(static_cast<Type>(this->_value), static_cast<Type>(v.GetValue()));
			if (std::fabs(this->_value + v.GetValue()) < std::fabs(max)) {
				throw NumOverflow(std::format("{} + {} is greater than the maximum value of type {} {}.\nnumerical overflow error.",
					this->_value, v.GetValue(), typeid(Type).name(), std::numeric_limits<Type>::max()));
			}
			else {
				return Number<Type>(this->_value + v.GetValue());
			}
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator +(const T2 v)const {
			using Type = std::common_type_t<T, T2>;
			auto max = std::max(static_cast<Type>(this->_value), static_cast<Type>(v));
			if (std::fabs(this->_value) + std::fabs(v) < max) {
				throw NumOverflow(std::format("{} + {} is greater than the maximum value of type {} {}.\nnumerical overflow error.",
					this->_value, v, typeid(Type).name(), std::numeric_limits<Type>::max()));
			}
			else {
				return Number<Type>(this->_value + v);
			}
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator -(const Number<T2>& v)const noexcept {
			using Type = std::common_type_t<T, T2>;
			if constexpr (std::is_signed_v<Type>) {
				operator-();
				return Number<Type>(this->_value + (-v.GetValue()));
			}
			else {
				return Number<Type>(this->_value -v.GetValue());
			}
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator -(const T2 v)const noexcept {
			using Type = std::common_type_t<T, T2>;
			if constexpr (std::is_signed_v<Type>) {
				operator-();
				return Number<Type>(this->_value + (-v));
			}
			else {
				return Number<Type>(this->_value - v);
			}
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator *(const Number<T2>& v)const {
			int64_t max = this->_value * v.GetValue();
			if (this->_value!=0 && max / this->_value!=v.GetValue()) {
				throw NumOverflow(std::format("{} * {} is greater than the maximum value of type {} {}.\nNumerical overflow error.",
					this->_value, v.GetValue(), typeid(T).name(), std::numeric_limits<T>::max()));
			}
			else {
				return Number<std::common_type_t<T, T2>>(this->_value * v.GetValue());
			}
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator *(const T2 v)const {
			int64_t max = this->_value * v;
			if (this->_value != 0 && max / this->_value != v) {
				throw NumOverflow(std::format("{} * {} is greater than the maximum value of type {} {}.\nNumerical overflow error.",
					this->_value, v, typeid(T).name(), std::numeric_limits<T>::max()));
			}
			else {
				return Number<std::common_type_t<T, T2>>(this->_value * v);
			}
		}

		template<typename T2>
		[[nodiscard]]  Number<std::common_type_t<T, T2>> operator /(const Number<T2>& v)const {
			if (v.GetValue() == -1) 
				throw NumOverflow("Division with a denominator of -1 will result in overflow");
			return Number<std::common_type_t<T, T2>>(this->_value / v.GetValue());
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator /(const T2 v)const {
			if (v == -1)
				throw NumOverflow("Division with a denominator of -1 will result in overflow");
			return Number<std::common_type_t<T, T2>>(this->_value / v);
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator %(const Number<T2>& v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value % v.GetValue());
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator %(const T2 v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value % v);
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator ^(const Number<T2>& v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value ^ v.GetValue());
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator ^(const T2 v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value ^ v);
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator &(const T2 v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value & v);
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator &(const Number<T2>& v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value & v.GetValue());
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator |(const T2 v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value | v);
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator |(const Number<T2>& v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value | v.GetValue());
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator <<(const T2 v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value << v);
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator <<(const Number<T2>& v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value << v.GetValue());
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator >>(const T2 v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value >> v);
		}

		template<typename T2>
		[[nodiscard]] constexpr Number<std::common_type_t<T, T2>> operator >>(const Number<T2>& v)const noexcept {
			return Number<std::common_type_t<T, T2>>(this->_value >> v.GetValue());
		}

		[[nodiscard]] constexpr Number<T> operator ~()const noexcept {
			return Number(~this->_value);
		}

		[[nodiscard]] constexpr bool operator !()const noexcept {
			return !bool(*this);
		}

		
		[[nodiscard]] constexpr Number operator -()const noexcept  {
			static_assert(std::is_signed_v<T>,"Unsigned Number cannot call unary operator -");
			if (this->_value == std::numeric_limits<T>::min())
				throw NumOverflow("operator - Overflow");
			return Number( - this->_value);
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator ==(const Number<T2>& v)const noexcept {
			return this->_value == v.GetValue();
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator ==(const T2& v)const noexcept {
			return this->_value == v;
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator !=(const Number<T2>& v)const noexcept {
			return !this->operator==(v);
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator !=(const T2& v)const noexcept {
			return !this->operator==(v);
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator <(const Number<T2>& v)const noexcept {
			return this->_value < v.GetValue();
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator <(const T2 v)const noexcept {
			return this->_value < v;
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator >(const Number<T2>& v)const noexcept {
			return !this->operator<(v);
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator >(const T2 v)const noexcept {
			return !this->operator<(v);
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator <=(const Number<T2>& v)const noexcept {
			return this->operator<(v) || this->operator==(v);
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator <=(const T2 v)const noexcept {
			return this->operator<(v) || this->operator==(v);
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator >=(const Number<T2>& v)const noexcept {
			return this->operator>(v) || this->operator==(v);
		}

		template<typename T2>
		[[nodiscard]] constexpr bool operator >=(const T2 v)const noexcept {
			return this->operator>(v) || this->operator==(v);
		}

		template<typename T2>
		constexpr void operator+=(const Number<T2>& v)noexcept {
			auto max = std::max(this->_value, static_cast<T>(v.GetValue()));
			if (this->_value + v.GetValue() < max) {
				throw NumOverflow(std::format("{} + {} is greater than the maximum value of type {} {}.\nNumerical overflow error.",
					this->_value, v.GetValue(), typeid(T).name(), std::numeric_limits<T>::max()));
			}
			else {
				this->operator+(v.GetValue());
				this->_value += v.GetValue();
			}
		}

		template<typename T2>
		constexpr void operator+=(Number<T2>&& v) {
			auto max = std::max(this->_value, T(v));
			if (this->_value + v.GetValue() < max) {
				throw NumOverflow(std::format("{} + {} is greater than the maximum value of type {} {}.\nNumerical overflow error.",
					this->_value, v.GetValue(), typeid(T).name(), std::numeric_limits<T>::max()));
			}
			else {
				this->operator+(v.GetValue());
				this->_value += v.GetValue();
			}
		}

		template<typename T2>
		constexpr void operator-=(const Number<T2>& v)noexcept {
			this->_value -= v.GetValue();
		}
		template<typename T2>
		constexpr void operator-=(Number<T2>&& v)noexcept {
			this->_value -= v.GetValue();
		}

		explicit constexpr operator T()const noexcept {
			return this->_value;
		}

		[[nodiscard]] constexpr Number* operator&()noexcept {
			return this;
		}

		explicit constexpr operator bool()const noexcept {
			return static_cast<bool>(this->_value);
		}

		template<typename T>
		auto operator<=>(const T& v)const noexcept {
			return this->_value <=> v;
		}

		[[nodiscard]] constexpr T GetValue()const noexcept {
			return this->_value;
		}

		[[nodiscard]] constexpr std::string to_string()const noexcept {
			return std::format("Number<{}>::_value is {}", typeid(T).name(), this->_value);
		}

	private:
		T _value{};
	};

	//Custom "number" literal
	auto operator "" _num(unsigned long long int lit)noexcept ->decltype(Number(lit))
	{
		return Number(lit);
	};

	auto operator "" _num(long double lit)noexcept ->decltype(Number(lit))
	{
		return Number(lit);
	};

	auto operator "" _num(char lit)noexcept ->decltype(Number(lit))
	{
		return Number(lit);
	};

	auto operator "" _num(wchar_t lit)noexcept->decltype(Number(lit))
	{
		return Number(lit);
	};

	auto operator "" _num(char16_t lit)noexcept ->decltype(Number(lit))
	{
		return Number(lit);
	};

	auto operator "" _num(char32_t lit)noexcept ->decltype(Number(lit))
	{
		return Number(lit);
	};

	//Output operator overloading
	template<number T>
	std::ostream& operator<<(std::ostream& out, Number<T>& v)noexcept {
		out << v.GetValue();
		return out;
	}
	template<number T>
	std::ostream& operator<<(std::ostream& out, Number<T>&& v)noexcept {
		out << v.GetValue();
		return out;
	}

	template<typename T,typename T2>
	auto operator<=>(const Number<T>& v1, const Number<T2>& v2)noexcept {
		return v1.GetValue() <=> v2.GetValue();
	}

	template<typename...Ts>
	auto min(Ts&&... xs) {
		return std::min({ std::forward<Ts>(xs)... }, std::less<>());
	}

	template<typename...Ts>
	auto max(Ts&&... xs) {
		return std::max({ std::forward<Ts>(xs)... }, std::less<>());
	}

	using uint64 = unsigned long long;
	using Int = Number<uint64>;
	using Char = Number<char>;
	using Schar = Number<signed char>;
	using Uchar = Number<unsigned char>;
}

完整项目地址:c-plus-plus/number/number at master · 13870517674/c-plus-plus · GitHub

 它的检测仍有问题，如有建议还望告知

mq白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++20 std::formatter的使用--格式化自定义类型
Aboes的博客
06-07 4925
C++20 std::formatter的使用--格式化自定义类型说明头文件一个简单的format例子格式化自定义类型（class，struct）新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 说明 C++在20标准中正式
std::numeric_limits 介绍
最新发布
qq_27390023的博客
04-05 590
头文件中定义的一个标记，用于设置流输出时，将布尔值解释为字符串 "true" 或 "false"，而不是整数 1 或 0。在 C++ 中，整数类型不具有可表示的精度，因此对于整数类型。模板类的一个静态成员常量，它用于获取类型。模板类的一个静态成员函数，用于获取类型。的十进制位数（即有效位数）。返回的值始终为 0。
c++ 虚函数基础1
西门吹雪
04-12 337
初识虚函数 虚函数 源码如下 #include <iostream> using namespace std; class A{ public: virtual void printAA(){cout<<"print A";} }; class B:public A{ public: virtual void printAA(){cout<<"print B";} }; int main() { A* a = new B(); a->printAA
C++编程->import函数
weixin_33883178的博客
04-06 845
#import指令用于从一个类型库中结合信息。该类型库的内容被转换为C++类,主要用于描述COM界面。 语法 #import "文件名" [属性] #import <文件名> [属性] 属性: 属性1,属性2,... 属性1 属性2 ... 文件名是一个包含类型库信息的文件的名称。一个文件可为如下类型之一: * ...
C/C++ C++20 格式化库 std::format
热门推荐
LU_ZHAO的博客
02-27 1万+
说明 文本格式化库提供 printf 函数族的安全且可扩展的替用品。有意使之补充既存的 C++ I/O 流库并复用其基础设施，例如对用户定义类型重载的流插入运算符。 头文件 #include <format> 函数定义 template<class... Args> std::string format(std::string_view fmt, const Args&a...
QT学习之 原来C++还没入门
mokey9180的专栏
03-13 1310
QOverload<>::of(&AnalogClock::update)看不懂，update应该是个槽函数，前面QOverload<>应该是个类模板类，具体的作用是啥。直接用&AnalogClock::update做连接不行吗？
C++中的重要知识！！！
03-08
本文将聚焦于C++中的一个重要概念——字符串Hash，及其在算法问题解决中的应用。 ### 字符串Hash 字符串Hash是一种将字符串转换为单一数值的技术，这有助于快速比较和查找字符串。在C++中，字符串Hash通常用于高效...
C++经典算法
08-04
这个例子展示了如何使用条件分支结构处理复杂的逻辑，并且注意到了在处理可能的大数值时，使用了长整型变量（`long int`）以避免数据溢出。 第三个程序是寻找一个特定的整数，使得这个数加上100后是一个完全平方数...
C++题集.pdf
03-11
这些题目涵盖了C++编程的基础和进阶知识，包括逻辑判断、循环控制、算术运算、字符串处理、条件语句、数组、函数应用、输入输出、数值计算、算法设计等多个方面。下面逐一解析： 1. 异或运算加密解密：异或运算是位...
C++题集(含答案).docx
03-11
16. **指数衰减**：根据给定的衰减率计算未来年份的数值，需要注意数值溢出问题。 17. **一元二次方程求根**：使用公式法或求根公式（如韦达定理）解决，要考虑根的实部和虚部。 18. **统计分析**：处理批量数据，...
【C++11多线程】原子操作＜atomic＞
cutemypig的博客
12-28 1323
索引1 头文件结构2 std::atomic 代码网址：https://github.com/jorionwen/threadtest 1 头文件结构 头文件：原子类型是封装了一个值的类型，它的访问保证不会导致数据的竞争，并且可以用于在不同的线程之间同步内存访问。 这个头声明了两个c++类，原子和atomic_flag，它实现了自包含类中的原子类型的所有特性。header还声明了整个C样式类型和函数与C中的原子支持兼容。头文件中结构定义查看。 头文件的结构： atomic 用于bool、整数和指针类型的原子
numeric_limits＜T＞::max()，min()及lowest()
m0_38086244的博客
06-11 607
td::numeric_limits<T>::max()，min()及lowest() 根據std::numeric_limits，如果T屬於浮點數，則： std::numeric_limits<T>::max()回傳該型別的最大值 std::numeric_limits<T>::min()回傳該型別的"最小正數" std::numeric_limits<T>::lowest()回傳該型別的最小值（為負數或0）。 如果T屬於整數，...
五、语言特性之＜=default,=delete、using、noexcept、override、final、以及和const对比＞
梦心之魂的博客
12-06 861
一、=default,=delete 1、首先我们要回顾一下类默认函数的概念： C++中，当我们设计与编写一个类时，若不显著申明，则类会默认为我们提供如下几个函数： （1）构造函数(A())、（2）析构函数（~A()）、（3）拷贝构造函数(A(A&))、（4）拷贝赋值函数（A& operator=(A&)）、（5）移动构造函数（A(A&&)）、(6）移动赋值函数（A& operator=(A&&)） 注意：拷贝函数如果涉及指针就要区分浅拷
C++11 带来的新特性 （3）—— 关键字noexcept
11-26 1467
1 关键字noexcept 从C++11开始，我们能看到很多代码当中都有关键字noexcept。比如下面就是std::initializer_list的默认构造函数，其中使用了noexcept。 constexpr initializer_list() noexcept : _M_array(0), _M_len(0) { } 该关键字告诉编译器，函数中不会发生异...
C++2.0 =default,=delete、alias(别名)、noexcept、override、final
youtiao_hulatang的博客
03-09 480
一、=default,=delete 1、首先我们要回顾一下类默认函数的概念： C++中，当我们设计与编写一个类时，若不显著申明，则类会默认为我们提供如下几个函数： （1）构造函数(A())、（2）析构函数（~A()）、（3）拷贝构造函数(A(A&))、（4）拷贝赋值函数（A& operator=(A&)）、（5）移动构造函数（A(A&&)）、(6）移动...
关于STL模板类自定义内存分配器
liulilittle的博客
08-04 328
关于STL模板类自定义内存分配器
C++新特性之Type Alias、noexcept、override、final
u013635579的博客
09-19 1176
1. Type Alias（类型别名）and Template Alias（模板别名） 在C++11中，我们不仅可以为类型定义别名，还可以对模板进行定义别名。 别名声明的语法 1. using identifier = type-id //identifier为引入的类型名，type-id为抽象声明器或者任何合法的type-id 2. template &lt;template-pa...
C++11异常处理 noexcept
zkreats的博客
01-20 1万+
1.简介在C语言中，当程序的运行出现异常、错误时，如果我们想为这些异常、错误提供解决方案时，我们面临许多问题，如： （1）C语言没有提供统一（标准）的方式来处理错误； （2）无法保证错误会被正确的处理； （3）错误的传播也无法控制，特别是在函数的嵌套调用时； … …当程序在运行时发生错误，使得程序的继续运行变得没有意义时，C++中的异常机制给我们提供了一个解决方法。2.C++03 异常处
c++11 类默认函数的控制："=default" 和 "=delete"函数 void fun() = default; void fun()=delete;...
weixin_30487701的博客
03-12 263
转自：lsgxeva #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <string> #include <vector> #include <map> //c++11 类默认函数的控制："=default" 和 "=delete"函数 /* C++ 的类有四类特殊...
用c++实现一个全局异常类
05-26
可以定义一个 `GlobalException` 类，它继承自 `std::exception`，并且重载 `what()` 函数来返回异常信息。 以下是一个示例代码： ```c++ #include #include class GlobalException : public std::exception { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值