int128的实现（基本完成）

已于 2024-02-25 11:32:01 修改
阅读量1.7k 收藏 9
点赞数 11
文章标签： c++
于 2024-02-22 20:40:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fool256353/article/details/136242468
版权

虽然有一个声明叫_int128但是这并不是C++标准：

long long 不够用？详解 __int128 - FReQuenter - 博客园 (cnblogs.com)

网络上去找int128的另类实现方法，发现几乎都是在介绍_int128的

然后我就自己想了个办法，当时还没学C++，用C草草写了下了事，也没有验证行不行

在这周一（2024/2/19）看了C++的类以及运算符重载之后，我打算拿int128来练练手

重载倒是很快练好了，但是代码有大问题：

int128的实现（未完成）-CSDN博客

int128的实现_实现一个int128的数-CSDN博客

可以看看我之前的愚蠢的代码

主要是完全没注意到数爆出2^64的问题（主要体

#ifndef CSTDIO_
#define CSTDIO_
#include<cstdio>
#endif

#ifndef CCTYPE_
#define CCTYPE_
#include<cctype>
#endif

#ifndef VECTOR_
#define VECTOR_
#include<vector>
#endif

#ifndef INT128_H_
#define INT128_H_

typedef unsigned long long LLU;//64位
typedef unsigned int U;//32位
const U MAX32 = 0xFFFFFFFF;
const LLU MAX64_U = 0xFFFFFFFF00000000;
const LLU _2POW32 = (LLU)MAX32 + 1;

class INT128{
    LLU A, B, C, D;
public:
    INT128(LLU tmp = 0){A = B = 0, C = (tmp & MAX64_U) >> 32, D = tmp & MAX32;};
    void getnum(void);
    INT128 operator-(const U & tmp) const;
    INT128 operator+(const LLU & tmp) const;
    INT128 operator+(const INT128 & tmp) const;
    INT128 operator*(const U & tmp) const;
    INT128 operator/(const U & tmp) const;
    INT128 operator%(const U & tmp) const;
    void operator=(const LLU & tmp);
    void show(void);

    inline void function1(std::vector<int> & tmp, LLU & data);
    inline void function2(std::vector<int> & tmp, LLU & data);
};

void INT128::getnum(void)
{
    A = B = C = D = 0;
    std::vector<int> tmp;
    char c;
    while(!isdigit(c = getchar()))
        ;//清空数字前面的东西
    do
    {
        tmp.insert(tmp.begin(), c - '0');
    }while(isdigit(c = getchar()));
    ungetc(c, stdin);
    //开始赋值
    function1(tmp, D), function1(tmp, C), function1(tmp, B);
    for(int i = tmp.size() - 1; i >= 0; i--)
        A = A * 10 + tmp[i];
}
INT128 INT128::operator-(const U & tmp) const
{
    LLU A1, A2, A3, A4;
    INT128 result(0);
    A1 = A, A2 = B, A3 = 0, A4 = (C << 32) + D - tmp;
    result.D = A4 & MAX32, A3 += (A4 & MAX64_U) >> 32;
    result.C = A3 & MAX32, A2 += (A3 & MAX64_U) >> 32;
    result.B = A2 & MAX32, A1 += (A2 & MAX64_U) >> 32;
    result.A = A1 & MAX32;
    return result;
}
INT128 INT128::operator+(const LLU & tmp) const
{
    LLU A1, A2, A3, A4;
    INT128 result(0);
    A1 = A, A2 = B, A3 = C, A4 = D + tmp;
    result.D = A4 & MAX32, A3 += (A4 & MAX64_U) >> 32;
    result.C = A3 & MAX32, A2 += (A3 & MAX64_U) >> 32;
    result.B = A2 & MAX32, A1 += (A2 & MAX64_U) >> 32;
    result.A = A1 & MAX32;
    return result;
}
INT128 INT128::operator*(const U & tmp) const
{
    LLU A1, A2, A3, A4;
    INT128 result(0);
    A1 = A, A2 = B, A3 = C, A4 = D;
    A1 *= tmp, A2 *= tmp, A3 *= tmp, A4 *= tmp;
    result.D = A4 & MAX32, A3 += (A4 & MAX64_U) >> 32;
    result.C = A3 & MAX32, A2 += (A3 & MAX64_U) >> 32;
    result.B = A2 & MAX32, A1 += (A2 & MAX64_U) >> 32;
    result.A = A1 & MAX32;
    return result;
}
INT128 INT128::operator/(const U & tmp) const
{
    LLU A1, A2, A3, A4;
    INT128 result(0);
    A1 = A, A2 = B, A3 = C, A4 = D;
    A2 += (A1 % tmp) << 32, A1 /= tmp;
    A3 += (A2 % tmp) << 32, A2 /= tmp;
    A4 += (A3 % tmp) << 32, A3 /= tmp;
    A4 /= tmp;
    result.D = A4 & MAX32, A3 += (A4 & MAX64_U) >> 32;
    result.C = A3 & MAX32, A2 += (A3 & MAX64_U) >> 32;
    result.B = A2 & MAX32, A1 += (A2 & MAX64_U) >> 32;
    result.A = A1 & MAX32;
    return result;
}
INT128 INT128::operator%(const U & tmp) const
{
    LLU A1, A2, A3, A4;
    INT128 result(0);
    A1 = A, A2 = B, A3 = C, A4 = D;
    A2 += (A1 % tmp) << 32;
    A3 += (A2 % tmp) << 32;
    A4 += (A2 % tmp) << 32;
    result.D = A4 % tmp;
    
    return result;
}
INT128 INT128::operator+(const INT128 & tmp) const
{
    LLU A1, A2, A3, A4;
    INT128 result(0);
    A1 = A + tmp.A, A2 = B + tmp.B, A3 = C + tmp.C, A4 = D + tmp.D;
    result.D = A4 & MAX32, A3 += (A4 & MAX64_U) >> 32;
    result.C = A3 & MAX32, A2 += (A3 & MAX64_U) >> 32;
    result.B = A2 & MAX32, A1 += (A2 & MAX64_U) >> 32;
    result.A = A1 & MAX32;
    return result;
}
void INT128::operator=(const LLU & tmp)
{
    A = B = 0, C = (tmp & MAX64_U) >> 32, D = tmp & MAX32;
}
void INT128::show(void)
{
    std::vector<int> tmp;
    //A放进数组
    LLU n_tmp = A;
    int ext = 0;
    while(n_tmp)
    {
        tmp.push_back(n_tmp % 10);
        n_tmp /= 10;
    }
    //B，C，D放进数组
    function2(tmp, B), function2(tmp, C), function2(tmp, D);
    
    //输出
    if(!tmp.size())  tmp.push_back(0);
    for(int i = tmp.size() - 1; i >= 0; i--)
        printf("%d", tmp[i]);
}
inline void INT128::function1(std::vector<int> & tmp, LLU & data)
{
    LLU ext = 0;
    bool jud = false;
    for(int i = tmp.size() - 1; i >= 0; i--)
    {
        ext = ext * 10 + tmp[i];
        tmp[i] = ext / _2POW32;
        jud = (jud || tmp[i]) ? true : false;
        if(!jud)  tmp.pop_back();
        ext %= _2POW32;
    }
    data = ext;
}
inline void INT128::function2(std::vector<int> & tmp, LLU & data)
{
    LLU n_tmp = 0;
    int ext = 0;
    for(int i = 0; i < tmp.size(); i++)
        n_tmp += _2POW32 * (LLU)tmp[i], tmp[i] = n_tmp % 10, n_tmp /= 10;
    while(n_tmp)
    {
        tmp.push_back(n_tmp % 10);
        n_tmp /= 10;
    }
    n_tmp = data, ext = 0;
    for(int i = 0; i < tmp.size(); i++)
    {
        ext += n_tmp % 10 + tmp[i];
        tmp[i] = ext % 10, ext /= 10, n_tmp /= 10;
    }
    n_tmp += ext;
    while(n_tmp)
    {
        tmp.push_back(n_tmp % 10);
        n_tmp /= 10;
    }
}

#endif

现在上面的第一篇博客，第二篇博客因为没专门写输入输出，所以没爆掉）

还有一个非常吃屎的东西：0xFFFFFFFF这个数，是2^32-1，不是2^32

顺便把输入吞掉一个字符的问题解决了（用了ungetc函数）

说说原理吧：

总所周知，我们这里的最高位的int的位数是64位（long long），最高表示的数是2^64-1（无符号），只有18,446,744,073,709,551,615大概10的20次方，有的时候是不够用的，用高精度数组的速度的效率又相对较慢，这时候就想到了int128了

但是只能你自己来实现（或者用上面的_int128啦，但是有的时候用不了），所以我就想了一种实现方法

用4个unsignedlonglongint值来记录4个数，分别代表x1 * 2^96, x2 * 2 ^ 64, x3 * 2^32, x4。这样加起来，就是一个int128的数了，而且不会爆掉（之前是用两个数记录高低位的，输入输出爆了，运算倒是没有）

然后按照数学的计算，就可以设计出加减乘除了

代码如下：

注：只有加法和赋值支持int128数，然后每种计算都支持常数，但是只有加法和赋值达到2^64-1，其他是2^32-1

至于为什么不让每种计算都支持int128嘛，因为懒得写了，还有乘法会爆int128、没必要，而且蓝桥杯要到了，我得加紧算法的学习了（这个东西花了我4天去改，虽然不是每一刻都在想，但是也挺搞事的）

Fool256353
关注
用C语言实现单链表的基本操作（附有完整代码）
m0_64365419的博客
10-22 7854
单链表的基本概念和定义以及实现过程。
编写实现单链表的各种基本运算，并在此基础上设计一个主函数完成如下功能：
Helioj的博客
05-28 3115
##单链表基本运算的笔记（可供一些初学者学习） （1）初始化单链表L。 （2）依次采用尾插法插入h、e、l、l、o。 （3）输出单链表L。 （4）输出单链表L的长度。 （5）判断单链表L是否为空。 （6）输出单链表L的第2个和第4个元素。 （7）输出元素o位置。 （8）在单链表L的第4个位置上插入元素r。 （9）输出单链表L。 （10）删除单链表L的第3个元素。 （11）输出单链表L。 （12）释放单链表L。 #include <stdio.h> #include <malloc.h&gt
C++编写128位整数运算源码
09-14
通过2个64位INT整数实现的128位整数运算，可容易的扩展到更高位数的整数运算。
c++__int128快读快写
2301_77950575的博客
07-15 250
【代码】c++__int128快读快写。
__int128
最新发布
weixin_61426225的博客
07-30 399
int128__int128并不是标准c/c++中的数据类型，而是一些特定编译器如gcc/g++提供的扩展数据类型。
三分模板+int128模板
我们仍未知道那天所看见的花的名字。
11-16 282
while(l<r) { ll midl=l+(r-l)/3; ll midr=r-(r-l)/3; if(check(midl)<=check(midr)) r=midr-1; else l=midl+1; } #include <bits/stdc++.h> using namespace std; inline __int128 read() { __int128
C++ int128
weixin_52559308的博客
11-21 3673
C++ int128 ** 快速地调用，一般的方法 ** 还可以，不过并不是最大的，有时还差点意思，相当于longlong强化版 #include<iostream> using in = signed long long int; int main(){ int n,m; std::cin >> n >> m; } 解题时使用的int128，避免了使用高精度的高代码强度 #include <bits/stdc++.h> using in =
__int128的实现
dav74739的博客
02-04 679
#include<bitset> #include<algorithm> #include<iostream> #include<string> #include<deque> #include<cstdio> using namespace std; class i...
int 128 实现
askyalive的专栏
01-31 1544
来源 http://www.pudn.com/downloads2/sourcecode/windows/other/detail4334.html   // ALU.h: interface for the CALU class. // //////////////////////////////////////////////////////////////////////
C/C++ __int128
qq_45560445的博客
11-28 1754
用来处理 long long 处理不了的整数但是数据范围又在128位以内的 #include <bits/stdc++.h> using namespace std; inline __int128 read(){ __int128 x = 0, f = 1; char ch = getchar(); while(ch < '0' || ch > '9'){ if(ch == '-') f = -1; c
C/C++ __int128的使用
热门推荐
Authur_gyc
09-02 2万+
gcc是不支持__int128这种数据类型的，比如在codeblocks 16.01也是无法编译的，但是提交到大部分OJ上是可以编译且能用的。C/C++标准IO是不认识__int128这种数据类型的，因此要自己实现IO，其他的运算，与int没有什么不同。 参考来源 博客 https://blog.csdn.net/tianwei0822/article/details/80687466 ...
int128_c++int128_
09-30
c++中int128的输入输出int128常用于1e30内的大数
C++代码实现栈基本操作
m0_67500944的博客
09-02 5977
C++代码实现栈基本操作，可以实现的，点进不亏
数据结构 C语言 实现单链表的各种基本操作
WindsProgrammer的博客
06-01 5540
大概写了150多行，都是很基础的操作。需要的自取。 （书籍为数据结构教程（第五版）李春葆） 实验内容 实验三 链表基本操作的实现 【实验目的】 1．掌握线性表的链式存储表示。 2．掌握单链表的基本操作，包括创建、查找、插入和删除等算法。 【实验内容】 编写程序linklist.cpp，实现单链表的各种基本运算（假设单链表的元素类型为char），并在此基础上设计主程序main.cpp，完成如下功能： 1．初始化单链表； 2．依次采用尾插法插入元素a，b，c，d，e； 3．输出单链表； 4．判断单链表的长度；
数据结构实现顺序表的各种基本运算（顺序表大菜单）
qq_62175345的博客
04-12 2566
编写程序，实现顺序表的各种基本运算，要求用菜单组织所有功能，程序界面友好，相应提示信息清晰完整，具有较强的容错性。要实现的功能有： （1）输出顺序表中的所有元素； （2）按序号查找指定元素，即输出顺序表中的第i个元素； （3）按值查找指定元素，即输出顺序表中值为x的元素的序号； （4）在指定位置插入元素，即在第i个元素前面插入值为x的元素； （5）删除指定元素，即删除第i个元素； （6）删除顺序表中所有值在[x,y]范围内的元素，要求时间复杂度达到O(n)； （7）单值化操作，即删除表中重复元
__int128详解(超详细)
darkmoonbird的博客
02-19 5651
__int128的使用以及例题讲解
关于 __int128
weixin_30596023的博客
12-13 511
__int128 是 GCC 提供的扩展（extension），可以当作 128 位整数使用。 关于 __int128 和 __int128_t Normally, _t suffix means a typedef, __ prefix means reserved for compiler and _ prefix means reserved for standard library; I...
关于__int128
b24384504986189的博客
08-15 317
参考：关于__int128 __int128本身可以进行的运算有+ - * / %还有各种位运算符 但是__int128不可以进行输入输出的操作，如果想要进行输入输出需要自定义函数 __int128可以在 64 位的编译器中运行 亲测__int128大概最多能够储存 4e22 左右的数 输入： void read(__int128 &x) { x=0; i...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值