NewInt 4

最新推荐文章于 2022-07-23 16:52:35 发布
最新推荐文章于 2022-07-23 16:52:35 发布
阅读量601 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/why_study/article/details/8440616
版权

发现了一个很严峻的问题，加法中有问题，所以又上传了一个版本，然后这个版本还实现了乘法，^ ^

然后就是感觉我的代码好凌乱啊，可维护性，可读性都超级弱爆了>.<董花花你还要继续加油啊。

然后上代码= =、

NewInt.h

#include <iostream>
#include <string>
class NewInt{
private:
	int *array;
	int length;
public:
	NewInt();
	NewInt(const char*s,int len);
	~NewInt(){
		/*if (array!=NULL)
		{
			delete[]array;
		}*/
	}
	void clear(){
		if (array!=NULL)
		{
			delete []array;
		}
	}
	void show();
	void changeToLonger(int len);
	void addToLast(int len);
	NewInt operator +(NewInt &ni);
	NewInt operator -(NewInt &ni);
	NewInt operator *(NewInt &ni);
	NewInt operator /(NewInt &ni);
	void setLength(int len);
	bool compare(int s1[],int s2[],int len);
	void quFan();//取反，起名无能表示压力很大
};

NewInt.cpp 

#include <iostream>
using namespace std;
#include "NewInt.h"
void NewInt::show(){
	if (array[0]==-1)
	{
		cout<<"-";
	}else{
	}
	for (int i = 1;i<length;i++)
	{
		cout<<array[i];
	}
	cout<<"  ";
}
NewInt::NewInt(){
	array =NULL;
	length = 0;
}
NewInt::NewInt(const char* s,int len){
	array = new int[len+1];
	if (s[0]=='-')
	{
		array[0] = -1;
		for(int i = 1;i<=len;i++){
			array[i] = s[i]-'0';
		}
	}else {
		array[0] = 0;
		for (int i = 1;i<=len;i++)
		{
			array[i] = s[i-1]-'0';
		}
	}
	length = len+1;
	
}

void NewInt::setLength(int len){
	array = new int[len];
	length = len;
}

bool NewInt::compare(int s1[],int s2[],int len){
	int flag = 0;
	for (int i = 1;i<len;i++)
	{
		if (s1[i]-s2[1]<0)
		{
			flag = 1;
		}
	}
	if (flag ==0)
	{
		return true;
	}else{
		return false;
	}
}
void NewInt::changeToLonger(int len){
    int *temp = array;
	if (array[0]==0)
	{
		array = new int[len];
		for (int i = len-length+1;i<len;i++)
		{
			array[i]=temp[i-(len-length)];
		}
		for (int j = 1;j<=len-length;j++)
		{
			array[j] = 0;
		}
		array[0]=0;
		length = len;
	}else if (array[0]==-1)
	{
		array = new int[len];
		array[0]=-1;
		for (int i = len-length+1;i<len;i++)
		{
			array[i]=temp[i-(len-length)];
		}
		for (int j = 1;j<=len-length;j++)
		{
			array[j] = 0;
		}
		length = len;
	}
	
}

void NewInt::quFan(){
	if (array[0]==0)
	{
		array[0]=-1;
	}else{
		array[0]=0;
	}
}

void NewInt::addToLast(int len){
	int *temp = array;
	array = new int[length+len];
	
	for (int i = length;i<length+len;i++)
	{
		array[i]=0;
	}
	for (int j = 0;j<length;j++)
	{
		array[j] = temp[j];
	}
	length = len+length;
}

NewInt NewInt::operator +(NewInt &ni){
	NewInt temp;
	if (length>=ni.length)
	{
		ni.changeToLonger(length);
		temp.setLength(length);
	}else{
		changeToLonger(ni.length);
		temp.setLength(ni.length);
	}
	if (array[0]==0&&ni.array[0]==0)
	{
		for (int i1 = 0;i1<temp.length;i1++)
		{
			temp.array[i1]=0;
		}
		for(int i = temp.length -1;i>=1;i--){
			if (temp.array[i]+array[i]+ni.array[i]<=9)
			{
				temp.array[i]+= array[i]+ni.array[i];
			}else {
				temp.array[i] += array[i]+ni.array[i]-10;
				temp.array[i-1]+=1;
			}
		}
		if (temp.array[0]>0)
		{
			temp.length++;
			int *tempArray = temp.array;
			temp.array = new int[temp.length];
			for (int i = temp.length;i>0;i--)
			{
				temp.array[i] = tempArray[i-1];
			}
			temp.array[0] = 0;
			
		}
	}else if (array[0]==0&&ni.array[0]==-1)//正数加上负数，你妹妹啊
	{
		for (int i1 =0;i1<temp.length;i1++)
		{
			temp.array[i1]=0;
		}
		if (compare(array,ni.array,temp.length))
		{
			for (int i = temp.length-1;i>=1;i--)
			{
				if (temp.array[i]+array[i]-ni.array[i]>=0)
				{
					temp.array[i]+=array[i]-ni.array[i];
				}else{
					temp.array[i]+=array[i]-ni.array[i]+10;
					temp.array[i-1]-=1;
				}
			}
		}else {
			temp.array[0] = -1;
			for (int i = temp.length-1;i>=1;i--)
			{
				if (temp.array[i]-array[i]+ni.array[i]>=0)
				{
					temp.array[i]+=ni.array[i]-array[i];
				}else{
					temp.array[i]+=ni.array[i]-array[i]+10;
					temp.array[i-1]-=1;
				}
			}
		}
	}else if (array[0]==-1&&ni.array[0]==0)//负数加正数，好玩吗吗
	{
		for (int i1 =0;i1<temp.length;i1++)
		{
			temp.array[i1]=0;
		}
		if (compare(array,ni.array,temp.length))
		{
			temp.array[0]=-1;
			for (int i = temp.length-1;i>=1;i--)
			{
				if (temp.array[i]+array[i]-ni.array[i]>=0)
				{
					temp.array[i]+=array[i]-ni.array[i];
				}else{
					temp.array[i]+=array[i]-ni.array[i]+10;
					temp.array[i-1]-=1;
				}
			}
		}else {
			for (int i = temp.length-1;i>=1;i--)
			{
				if (temp.array[i]-array[i]+ni.array[i]>=0)
				{
					temp.array[i]+=ni.array[i]-array[i];
				}else{
					temp.array[i]+=ni.array[i]-array[i]+10;
					temp.array[i-1]-=1;
				}
			}
		}

	}else {
		temp.array[0]=-1;
		for (int i1 =1;i1<temp.length;i1++)
		{
			temp.array[i1] = 0;
		}
		for(int i = length -1;i>=1;i--){
			if (temp.array[i]+array[i]+ni.array[i]<=9)
			{
				temp.array[i]+= array[i]+ni.array[i];
			}else {
				temp.array[i] += array[i]+ni.array[i]-10;
				temp.array[i-1]+=1;
			}
		}
		if (temp.array[0]>=0)
		{
			temp.length++;
			int *tempArray = temp.array;
			temp.array = new int[temp.length];
			for (int i = temp.length;i>0;i--)
			{
				temp.array[i] = tempArray[i-1];
			}
			temp.array[1]+=1;
			temp.array[0] = -1;
			
		}
	}
	return temp;
	
}

NewInt NewInt::operator -(NewInt &ni){
	NewInt temp;
	ni.quFan();
	temp=*this + ni;
	return temp;
}

NewInt NewInt::operator *( NewInt &ni){
	//先初始化temp使得temp与this相同长度，但是均为0
	NewInt temp;
	temp.setLength(length);
	for (int i =0;i<temp.length;i++)
	{
		temp.array[i]=0;
	}


	if ((array[0]==0&&ni.array[0]==0)||(array[0]==-1&&ni.array[0]==-1))//正数乘以正数
	{
		for (int i = 1;i<ni.length;i++)
		{
			int j = ni.array[i];

			NewInt middleValue1 ;
			middleValue1.setLength(length);
			for (int z = 0;z<length;z++)
			{
				middleValue1.array[z] = array[z];
			}

			NewInt middleValue2 ;
			middleValue2.setLength(length);
			for (int z1 = 0;z1<length;z1++)
			{
				middleValue2.array[z1] = 0;
			}

			while (j!=0)
			{
				middleValue2=middleValue2+middleValue1;
				j--;
			}
			middleValue2.addToLast(ni.length-i-1);
			temp =temp+middleValue2;
		}
		temp.array[0]=0;
	}else if ((array[0]==0&&ni.array[0]==-1)||(array[0]==-1&&ni.array[0]==0))
	{
		for (int i = 1;i<ni.length;i++)
		{
			int j = ni.array[i];
			
			NewInt middleValue1 ;
			middleValue1.setLength(length);
			for (int z = 0;z<length;z++)
			{
				middleValue1.array[z] = array[z];
			}
			
			NewInt middleValue2 ;
			middleValue2.setLength(length);
			for (int z1 = 0;z1<length;z1++)
			{
				middleValue2.array[z1] = 0;
			}
			
			while (j!=0)
			{
				middleValue2=middleValue2+middleValue1;
				j--;
			}
			middleValue2.addToLast(ni.length-i-1);
			temp =temp+middleValue2;
		}
		temp.array[0]=-1;
	}
	return temp;
}

main.cpp 

#include "NewInt.h"
#include <cstring>
#include <iostream>
using namespace std;
void main(){
	char s[]= {'-','5',NULL};
	char s1[] = {'-','5','5',NULL};
	NewInt new1(s,strlen(s)-1);
	NewInt new2(s1,strlen(s1)-1);
	new1.show();
	new2.show();
	NewInt new3;
	new3 = new1*new2;
	new3.show();
	new1.clear();
	new2.clear();
	new3.clear();
}

然后就是代码的质量实在是太差了，然后感觉计算效率也很低= =、

callmedhh
关注
专栏目录
C++中之a[5](栈区)和int a=new int[5](堆区)有什么区别
码莎拉蒂
03-18 5216
1、int* a=new int[5]需要判断内存是否分配成功，以及在不用时需要使用delete[] a进行内存释放； 2、如果不是a[5]，而是a[5000000000]或者更大的话，那一般情况下，就只能使用int* a=new这种方式了。这个涉及到内存存放位置的问题，int a[]这种方式，内存是存放在栈上,比如我们函数的参数和局部变量内存也放在栈上；int* a＝new这种方式，内存...
Java基础（5）-- 数组
littlerain666
07-19 208
一、数组定义 1、数据类型[] 数组名 = new 数据类型[元素个数或数组长度]; int[] x; // 声明一个int[]类型的变量 x = new int[100]; // 创建一个长度为100的数组 数据类型 默认初始化值 byte、short、int、long 0 ...
C++使用new关键字声明int数和int数组
weixin_53068653的博客
04-12 2483
关键字new new ：申请一个动态全局的空间，要手动释放内存 可以new一个int类型的数，也可以new一个int类型的数组 返回的是一个指针类型 #include<iostream> using namespace std; int *f1(){ //a指向一个值为123的int数 int *a = new int(123); return a; } int *f2(){ int *b = new int[2]; b[0] = 0; b[1] = 1; } int main()
【Java基础03_数组】
ityin的博客
07-23 93
java基础 数组
学习笔记：JAVA的数组(Array)
m0_45237843的博客
09-25 287
数组Array
第四次
yangbinghui的博客
04-13 79
package SHUANGE; /* 2021-3-28 *杨炳辉 */ public class A1 { public static void main(String[] args) { int []a={16,25,9,90,23}; for (int i=0;i< a.length-1;i++){ for (int j = 0; j < a.length-1-i; j++) { if (a[j]>a[j+1]){ int temp=a[j]; a[j]=a[j+1]; a[j+
memset和指针new一起使用时请小心
sinat_23135151的博客
03-10 4987
首先，我们知道，memset(数组名如A，0，sizeof(A))和memset(数组名如A，-1，sizeof(A))分别能够将整个数组A初始化为0和-1（前者0，后者-1）。 利用new的方法获得指定长度的动态分配内存的数组，此时memset不适用，那是因为sizeof(A)不是数组尺寸，而仅仅是该元素的size如int 4； #include using namespace std;
【C++】内存的存储方案与动态分配new的讲解
王博（Kings）的博客
07-19 1655
目录 1. 基本知识 什么是动态内存？ 编译器分配3种内存： 2. new 运算符 2.1 使用new运算符时的初始化 2.2 new失败时如何处理？ 2.3. new：运算符，函数和替换函数 2.4. 定位运算符new 示例程序 1. 基本知识 什么是动态内存？ 使用new和delete（C语言中使用函数malloc( )）分配的内存，我们叫做动态内存。动态内存由new...
golang--基本数据类型,big.Int类型,类型转换
weixin_42248522的博客
07-30 9568
nil 是 interface、function、pointer、map、slice 和 channel 类型变量的默认初始值 不可以用"=="比较类型： slice（切片）、map（key-value集合）、func（函数） map的比较可以使用reflect.DeepEqual() m1 := map[string]string{"one": "a", "two": "b"} m2 := map[string]string{"two": "b", "one": "a"} // 1.map类型
C++中用new给二维数组分配内存的使用方法
qq_42408736的博客
04-14 1660
C++中用new给二维数组分配内存的使用方法 一、原理 首先要分开分配内存，如果还是用原来的一维数组的动态分配就不行了，比如 int** ptr = new int* [10 * 10]; /这句是指分配了100个int指针，并不是一1010的2维数组。*/ 二、使用步骤 1.先创建一个10个int型指针数组 int **ptr = new int *[10]; //指针的数组 2.在分别给每个指针的头指针分配内存 for(int i=0;i<10;i++){ ptr[i]=new int[
Java学习路线：day6 数组
杨丙寅
05-18 1245
文章目录第3章 数组3.1 数组的概述3.2 一维数组的使用内存的简化结构一维数组的内存解析练习13.3 多维数组的使用二位数组二维数组的内存解析 https://shimo.im/docs/TcdrXydwCTHY866T/ 《第3章 数组》 第3章 数组 3.1 数组的概述 /* * 一、数组的概述 * 1.数组的理解：数组(Array)，是多个相同类型数据按一定顺序排列的集合， *...
java:不对数组进行排序，对数组中重复的数进行去重,在重复的数中保留一个。
qq_41252120的博客
10-17 826
import java.util.Scanner; public class RemoveDuplicate { public static void main(String[] args) { //创建去重类对象 RemoveDuplicate rd=new RemoveDuplicate(); System.out.println("请输入数组长度："); //1.输入数组长度 int len=i.
int [][]a=new int[4][4]
lz12366007的专栏
10-14 3915
 高人指点：int[4][4] a=new   int[][]; 你只是在栈上申请了一个可以维护 int[4][4]得引用而已,new之后的才是真正要再堆上分配[4][4]内存，你不给他，他怎么会知道呢？回答1： int[] tempt=null; //申明一个整型的数组 tempt=new int[0];//创建一个容量为0的数组，并让tempt指向它 =============
c++学习之new int()和new int[]的区别
热门推荐
郭小郭的专栏
12-17 4万+
new int[] 是创建一个int型数组，数组大小是在[]中指定，例如： int * p = new int[3]; //申请一个动态整型数组，数组的长度为[]中的值  new int()是创建一个int型数，并且用()括号中的数据进行初始化,例如： int *p = new int(10); // p指向一个值为10的int数。 在这里我想说一下，有些书上写的是为指针开辟10个字节
理解int(*p)[4] = new int[3][4];
Shylock_wu的博客
04-13 1790
1.int *p = new int [4] int *p = new int [4]; 可理解为 int a[4]; int *p = a; 此条语句中，我们定义的是一个指针变量p，这个指针p指向一个拥有四个int类型的元素的数组的首地址。 对指针(p+i)解引，可得到a[i]中的元素。 2.int (*p)[4] = new int[3][4] int (*p)[4] =...
C++变长数组
程序猿老樊的博客
08-31 2万+
什么是变长数组？    变长数组是指在编译时不能确定数组长度，程序在运行时需要动态分配内存空间的数组。 1.普通方式实现一维变长数组： #include using namespace std; int main() { int len; cin>>len; //用指针p指向new动态分配的长度为
new int[]含义
最新发布
05-19
new int[]是用于在内存中动态分配一个整型数组的关键字。它会在堆上分配一段连续的内存空间来存储整型数组，并返回该数组的地址。使用new int[]时需要指定数组的长度，例如：new int[10]会分配一个长度为10的整型数组。同时，也可以在初始化时为数组赋初值，例如：new int[]{1, 2, 3, 4, 5}会分配一个包含5个元素的整型数组，并将其初始化为1、2、3、4和5。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值