NewInt5

数字IC/FPGA 秋招知识点不全面整理 阅读详情

勤劳的董花花又来贴代码了= =、

这一次实现了加减乘除和赋值还有<<功能

然后贴代码啦

NewInt.h

#include "iostream.h"
#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 changeToLonger(int len);
	void addToLast(int len);
	NewInt operator +(NewInt &ni);
	NewInt operator -(NewInt &ni);
	NewInt operator *(NewInt &ni);
	NewInt operator /(NewInt &ni);
	NewInt& operator =(const NewInt &ni);
	friend ostream & operator<<(ostream&out,NewInt &ni);
	void setLength(int len);
	bool compare(int s1[],int s2[],int len);
	void quFan();//取反,起名无能表示压力很大
};

NewInt.cpp

//4.定义一个不受计算机字长限制的整数类INT,要求INT与INT以及INT与C++基本数据类型int之间能进行+、-、×、÷和=运算,
//并且能通过cout输出INT类型的值。
#include "iostream.h"
#include "NewInt.h"

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;
	NewInt middleValue;
	middleValue.setLength(ni.length);
	for (int i = 0;i<ni.length;i++)
	{
		middleValue.array[i]=ni.array[i];
	}
	middleValue.quFan();
	temp=*this + middleValue;
	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;
}

NewInt NewInt::operator /(NewInt &ni){
	NewInt temp;
	temp.setLength(2);
	temp.array[0]=0;
	temp.array[1]=0;
	
	NewInt middleValue;
	middleValue.setLength(2);
	middleValue.array[0]=0;
	middleValue.array[1]=1;

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

	if (array[0]==0&&ni.array[0]==0)
	{
		while (middleValue1.array[0]==0)
		{
			middleValue1 = middleValue1-ni;
			temp = temp+middleValue;
		}
		temp = temp -middleValue;
	}else if (array[0]==0&&ni.array[0]==-1)
	{
		NewInt middleValue2;
		middleValue2.setLength(ni.length);
		for (int i = 0;i<ni.length;i++)
		{
			middleValue2.array[i]=ni.array[i];
		}
	    middleValue2.quFan();

		while (middleValue1.array[0]==0)
		{
			middleValue1 = middleValue1-middleValue2;
			temp = temp+middleValue;
		}
		temp = temp -middleValue;
		temp.array[0]=-1;
	}else if (array[0]==-1&&ni.array[0]==0)
	{
		while (middleValue1.array[0]==-1)
		{
			middleValue1 = middleValue1+ni;
			temp = temp+middleValue;
		}
		temp = temp -middleValue;
		temp.array[0]=-1;
	}else{
		middleValue1.quFan();
		while (middleValue1.array[0]==0)
		{
			middleValue1 = middleValue1+ni;
			temp = temp+middleValue;
		}
		temp = temp -middleValue;
		temp.array[0]=0;
	}
	return temp;
}
//NewInt& operator =(const NewInt &ni);
NewInt& NewInt::operator =(const NewInt &ni){
	length =ni.length;
	int *temp = new int[ni.length];
	for (int i =0;i<ni.length;i++)
	{
		temp[i] =ni.array[i];
	}
	delete []array;
	array = temp;
	return *this;
}

ostream & operator<<(ostream&out,NewInt &ni){
	if (ni.array[0]==-1)
	{
		out<<"-";
	}
	for (int i = 1;i<ni.length;i++)
	{
		out<<ni.array[i];
	}
	return out;
}

main.cpp

#include "NewInt.h"
#include <cstring>
#include "iostream.h"
void main(){
	char s[]= {'-','2','0',NULL};
	char s1[] = {'-','5',NULL};
	NewInt new1(s,strlen(s)-1);
	NewInt new2(s1,strlen(s1)-1);
	cout<<new1<<endl;
	cout<<new2<<endl;
	new1.clear();
	new2.clear();
}

然后跟int直接的运算等等上恩。

将指定文件夹下每张用LabelImg标注的图片中标注部分抠出来保存到指定文件夹下。 阅读详情

相关推荐

香橙派5B-RK3588-NPU内核升级至0.9.8:RKLLM多模态部署实战

本文详细介绍了香橙派5B-RK3588设备NPU内核升级至0.9.8版本的完整流程,重点讲解了升级的必要性、两种升级方案(预编译包安装与自行编译内核)以及RKLLM SDK的安装配置。通过实战演示多模态模型转换与推理,显著提升AI计算性能,为嵌入式AI部署提供实用指南。

salt9的博客 1028

int* pInt = new int(5);和int* pInt = new int[5];

int *p = new int(5); 这句是从堆上分配一个int型变量所占的字节内存,这个内存单元存放的整数值为5,然后让一个整形的指针变量p指向它的地址。释放方式:delete p;int *p = new int[5]; 这句相当于从堆上分配一个含有5个元素的整形数组所占的字节内存,然后让一个整形的指针变量p指向它的首址。释放方式:delete []p;(注意这个[]不能掉了,如...

weixin_30417487的博客 781

微信小程序URL Link全解析:从生成原理到实战应用(附Java代码)

本文深入解析微信小程序URL Link的生成原理与实战应用。URL Link是微信官方提供的智能路由协议,通过中间页实现外部链接安全跳转至小程序指定页面。文章详细阐述了其权限模型、环境版本差异及跳转机制,并提供了包含令牌管理、异常处理和性能优化的健壮Java实现方案,助力开发者构建高可用的链接生成服务。

weixin_29327525的博客 1222

关于new运算符的一些思考

在C++中,new int[5]分配了一个足以存储5个整数的内存块,而new int(5)则为一个初始值为5的单个整数分配了内存。下面是这两者之间的一些关键区别:存储:new int[5]在连续的内存中分配了一个5个整数的数组,而new int(5)在单独的内存中分配了一个单一的整数。访问:使用new int[5]后,你可以使用数组索引访问数组中的每个元素,比如ptr[0],ptr[1],等等。在使用new int(5)后,你可以使用指针本身直接访问存储在ptr中的单个整数,像*ptr。

FOr_BIts的博客 715

别再只用真彩色了!手把手教你用ENVI主成分分析(PCA)给遥感图像‘美颜’与‘瘦身’

本文详细介绍了如何利用ENVI主成分分析(PCA)技术优化遥感图像处理,实现数据‘美颜’与‘瘦身’。通过PCA的维度压缩、噪声分离和特征增强三大优势,显著提升高光谱数据的可视化效果和分析效率。文章还提供了ENVI操作的最佳实践和常见问题解决方案,帮助读者掌握这一遥感图像处理的游戏规则改变者。

weixin_28465009的博客 277

uniapp H5刷新页面后返回按钮失效问题完美解决方案

这个问题其实很隐蔽,尤其是uniapp H5 场景下刷新导致栈清理,很多开发者一开始都懵掉了。uniapp 内部对「页面栈只有一个」时的返回逻辑是reLaunch;所以只要在这个分支里替换为自己的逻辑(比如),就能顺利实现预期。目前我在项目里已经跑通了,暂时没发现问题。不得不说,知道源码里这个逻辑后,真的是醍醐灌顶,只能膜拜框架大佬了 🤯。

代码简单说 Vue、JAVA、PHP、Node.js 熟练运用,接口、架构、性能全搞定。 526

定义一个不受计算机字长限制的整数类INT,要求INT与INT以及INT与C++基本数据类型int之间能进行+、-、×、÷和=运算,并且能通过cout输出INT类型的值。(持续添加)

题目要求:定义一个不受计算机字长限制的整数类INT,要求INT与INT以及INT与C++基本数据类型int之间能进行+、-、×、÷和=运算, 并且能通过cout输出INT类型的值。 一直就在构思这个程序肿么写,然后稍微有了一点点构思,但是由于我太笨了,所以今天只实现了+的一半的操作,但是呢,不想码了,今天先碎告了。明天继续加油~ 文件清单: main.cpp #include "

汪海的学习笔记 3228

再相逢【知识图谱】中文医学知识图谱CMeKG,中文产科医学知识图谱COKG | 附:图数据库Neo4j下载安装教学(遇到问题并解决) + Neo4j基本操作

本篇文章介绍知识图谱的相关知识。从便于理解的角度切入,给出知识图谱的形象化定义,并介绍了国内的中文医学知识图谱CMeKG,还以用户视角体验了中文产科医学知识图谱。目录二介绍了如何部署安装Neo4j数据库,并解决了部署过程中遇到的一些基础错误,随后介绍了Neo4j图数据库的基础操作。

追光者♂:记录、分享、总结、提升,现象级专栏《Python从入门到人工智能》作者,无惧黑暗,坚信曙光 2620

JAVA数组

JAVA数组

qq_46219566的博客 1013

ACS运动控制器编程 怎么学习

本文介绍了ACS运动控制器编程的完整学习路线,从零基础到实战应用。ACS是以色列高端多轴运动控制平台,适用于自动化设备、精密平台等项目。学习路径包括:1)安装官方软件SPiiPlusControlSuite;2)掌握轴、运动模式和指令三个核心概念;3)学习10个基础指令;4)编写首个运动程序;5)结合C#进行联合编程。进阶内容包括多轴同步、电子凸轮等工业应用,并推荐官方手册作为主要学习资源。通过7天的系统学习,即可掌握单轴运动控制,结合C#实现工业级设备开发。

StevenChen的博客 1336

睿抗机器人魔力元宝在完成任务过程中如何使机械臂先到达白色盒子上方而不是先到达工作台?

🏆 本文收录于《全栈Bug调优(实战版)》专栏,致力于分享我在项目实战过程中遇到的各类Bug及其原因,并提供切实有效的解决方案。无论你是初学者还是经验丰富的开发者,本文将为你指引出一条更高效的Bug修复之路,助你早日登顶,迈向财富自由的梦想🚀!同时,欢迎大家关注、收藏、订阅本专栏,更多精彩内容正在持续更新中。让我们一起进步,Up!Up!Up!    备注: 部分问题/难题源自互联网,经过精心筛选和整理,结合数位十多年大厂实战经验资深大佬经验总结所得,数条可行方案供所需之人参考。

**My Coding Family** 1379

C/C++中new的使用规则

C/C++中new的使用规则 本人未重视new与指针的使用,终于,终于在前一天船翻了,而且没有爬上岸; 故此,今特来补全new的用法,及其一些规则; 话不多说 C++提供了一种“动态内存分配”机制,使得程序可以在运行期间,根据实际需求,要求操作系统临时分配一片内存空间用于存放数据; 通过new运算符来实现; new实现一维指针: 1 int * P; 2 P = new int; //开辟一个存放整数的空间,并返回一个存储空间的地址(即指针); 3 * P =

qq_41779169的博客 742

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

在java中定义一个长度为5的整数数组,用冒泡排序从小到大排序

可以这样定义一个长度为 5 的整数数组: int[] arr = new int[5];

weixin_42600407的博客 1024

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

c++难点(较高级使用技巧)总结

目录(?)[+] 一数组名和指针的深入理解二函数名与函数指针三函数参数的传递问题一级指针和二级指针四int pInt new int5和int pInt new int5五数组作为函数参数及作为函数模版参数的总结 一、数组名和指针的深入理解 指针是C/C++语言的特色,而数组名与指针有太多的相似,甚至很多时候,数组名可以作为指针使用。于是乎,很多程序设计者就被搞糊涂了。

Dances with Wolves 的专栏 1010

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

java中的多维数组

在Java中,二维数组是一个数组的数组,也就是说它的每个元素都是一个数组。

卡布厨房 241

java如何创建一维数组

声明数组之后,还要分配内存空间。在为数组分配内存空间,必须指明长度。数组元素类型 数组名=new 数组元素类型[数组元素的个数];数组名字=new 数组元素类型[数组元素的个数];如果要同时声明数组和分配内存空间,语法格式如下。java创建一维数组,如果不赋值,格式是。数组元素类型 数组名字[ ];数组元素类型[ ] 数组名字;连同上面的声明一维数组代码一起。

2301_81968528的博客 216

Java数组的使用

Java 数组是一种非常有用的数据结构,它用于存储相同类型的元素,并且可以通过下标访问。在本文中,我们将介绍 Java 数组的使用,包括如何声明、创建、初始化和使用数组。

qq_61984546的博客 847

Java日记2——数组

二维数组好比一个表格,第一个下标表示行,第二个下标表示列,数组的创建和初始化与一位数组一模一样,及二维数组就是一个把多个一维数组包起来的数组。type[][] arrayName=new type[][]{{值1,值2,值3},{值1,值2,值3}};type[][] arrayName={{值1,值2,值3},{值1,值2,值3}};2.数据类型[ ] 变量名=new 数据类型[ ]{元素1,元素2,元素3};3.数据类型[ ] 变量名={元素1,元素2,元素3}(3)数组的初始化:为元素数组赋值。

QQJ__的博客 128

数组初始化之动态初始化

数组动态初始化

qq_52629349的博客 1089

c++array

在堆上创建数组,生存周期是主动销毁之前都是活动状态。程序在访问这给数组时会先访问指针地址,再跳转到数值,这种方式是间接寻址,影响性能。在栈上创建数组,生存周期一个代码块。可能的话应该尽量在栈上面创建数组来避免性能影响。c++数组是一个连续的数据块,

qq_43485816的博客 156

java数组

5.int[] newArray = Arrays.copy of(array,10)产生一个长度为10的新数组并且默认之前的数组。3.Array.sort(array)将array这个数组里的元素按照升序的方式重新排列。1.Arrays.toSring(array)展示array这个数组里的所有元素。4.array[array.lenth-1]=num数组最后一位为空值。列如:int[] array =new int [5];数组名[下标]------数组里对应位置的变量的名字。

2402_82425464的博客 1836

C++中int a[5]和 int *a=new int[5]有什么区别

各项区别如下: 1、如果只是int a[5]和int* a=new int[5]比较的话,前者可能还更简单一点。只是在使用上int* a=new int[10]需要判断内存是否分配成功,以及在不用时需要使用delete[] a进行内存释放;      2、如果不是a[5],而是a[5000000000]或者更大的话,那一般情况下,就只能使用int* a=new这种方式了。这个涉及到内存存放位置的问题,int a[]这种方式,内存是存放在栈上;int* a=new这种方式,内存是存放在堆上,栈的实际内存是连续

Leiroy的博客 1935

10-数组的动态初始化及默认初始化类型

静态初始化能够一次性为数组所有元素分配空间并赋初值,适用于元素数量较少、初值确定的情况;而动态初始化需要手动为每个元素赋值,适用于元素数量未知、初值不确定的情况。

记录java学习日常~ 880

Java数组

声明一个数组就是在内存空间划出一 串连续的相同类型的空间。数组的长度一旦给定 就不能修改。数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。数组是一组相关数据的集合,一个数组实际上就是一连串的变量。数组使用下标(角标)来访问元素(保存元素) 下标从。数组既可以存储基本数据类型,也可以存储引用数据类型。声明一个变量就是在内存空间划出一块空间。[ ]中5就是数组array的长度。代表: 数组中盛放数据的 数据类型。数据类型[] 数组名 = 初值。

m0_66843764的博客 74

Java二维数组以及Arrays类

二维数组 多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一堆数组,其每一个元素都是一个一维数组 二维数组: int a[][]=new int[2][5]; 这个数组可以看成一个二行五列的数组

weixin_58036127的博客 473

java 数组基础

二.int[] array1 = new int[]{1,2,3,4,5,6,7};数组本身就是一种数据类型 可以存放别的数据 基本数据类型和引用数据类型。三.int[] array2 = {1,2,3,4,5,6,7,8,9};一.int[] array = new int[5];索引:下标/脚标 用来寻找容器里面的数据的 从0开始, 数组的最大索引是最大减1。数组:内存空间连续的,相同数据类型的集合。数组的长度 数组名.length (数组中的元素个数)1.声明 3种方式。

2301_79080050的博客 109
上一篇: NewInt 4
下一篇: 各种小东西
callmedhh
博客等级 码龄14年 19粉丝 22原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值