使用链栈的小数和非负数的四则运算（非树形结构）

最新推荐文章于 2024-05-16 14:05:08 发布
最新推荐文章于 2024-05-16 14:05:08 发布
阅读量325 收藏 2
点赞数
分类专栏： 计算机算法 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/My_charming/article/details/105208412
版权

四则运算

写在前面

学过数据结构的同学都知道中缀和后缀算法，但是记不太清楚了。

本文通过建立两个栈的方法，直接从输入端调用进行运算，方便广大未学过数据结构或是对数据结构不熟悉的同学学习交流。

核心算法源自 《软件技术基础》 ——西安电子科技大学出版社

任务目标

通过 栈 方法实现基本的四则运算。

一个栈用于存放数值，另一个栈用于放置操作符。

通过四则运算练习链栈的创建、访问、置空，和节点元素的插入、删除等操作，并合理运用C++中的函数重载，实现浮点数和字符的操作。

结构框架

在这里插入图片描述
栈结构
在这里插入图片描述核心算法
在这里插入图片描述

算法分析

链栈

栈的构建
创建节点结构
typedef struct node
{
	int flag; //标记位，1为浮点数，2为字符型 
	datatype num;
	chartype sign;
	node* next;
}node;
//栈结构
typedef struct Sqstack
{
	node *Top;
}SqStack;
栈的声明
//构造一个空栈 
void InitStack(SqStack *& S);
//置空栈
void SetNull(SqStack *S); 
//判断栈空
int Empty(SqStack*S);
//函数重载
//出栈 根据格式返回需要的元素
void Pop(SqStack *S,datatype &e);
void Pop(SqStack *S,chartype &e);
//入栈 根据格式返回需要的元素
void Push(SqStack *S,datatype n);
void Push(SqStack *S,chartype s);
//获得栈顶元素 根据格式返回需要的元素
void GetTop(SqStack *S,datatype &e);
void GetTop(SqStack *S,chartype &e);
栈的基本功能
//构造一个空栈 
void InitStack(SqStack *& S)
{
	S = (SqStack*)malloc(sizeof(SqStack));
	S->Top = NULL;
}

//置空栈
void SetNull(SqStack *S)
{
	node* p = NULL;
	while(S->Top != NULL)
	{
		p = S->Top;
		S->Top = p->next;
		free(p);p = NULL;
	} 
	cout<<"置空成功"<<endl;
}

//判断栈空,空返回1 
int Empty(SqStack*S)
{
	if(S->Top<=0) return 1;
	else return 0;
 } 

//入栈 
void Push(SqStack *S,datatype n)
{
	node *p = (node*)malloc(sizeof(node));
	if(p != NULL)
	{
		p->flag = 1;
		p->num = n;
		p->next = S->Top;
		S->Top = p;
		cout<<"Num入栈成功:"<<p->num<<endl;
	}
	else 
		cout<<"Error"<<endl;
}
void Push(SqStack *S,chartype s)
{
	node *p = (node*)malloc(sizeof(node));
	if(p != NULL)
	{
		p->flag = 2;
		p->sign = s;
		p->next = S->Top;
		S->Top = p;
		cout<<"Sign入栈成功:"<<p->sign<<endl;
	}
	else 
		cout<<"Error"<<endl;
}

//出栈 
void Pop(SqStack *S,datatype &e)
{
	if(S->Top != NULL)
	{
		node* p = S->Top;
		e = p->num;
		S->Top = p->next;
		free(p);
		cout<<"出栈成功: "<<e<<endl;
	}
	else {}
}
void Pop(SqStack *S,chartype &e)
{
	if(S->Top != NULL)
	{
		node* p = S->Top;
		e = p->sign;
		S->Top = p->next;
		free(p);
		cout<<"出栈成功: "<<e<<endl;
	}
	else {}
}

//获得栈顶元素 
void GetTop(SqStack *S,chartype &e)
{
	if(S->Top != NULL)
		e = S->Top->sign;
	else {}
}
void GetTop(SqStack *S,datatype &e)
{
	if(S->Top != NULL)
		e = S->Top->num;
	else {}
}

四则运算

函数声明
//判断是否为字符型，是返回1，否返回0 
int CharOrNot(char ch); 
//输入表达式保存 
void GetExpression(SqStack *&S);
//输入输出对换 
void ReturnStack(SqStack *&S);
//四则运算 
datatype EvaluateExpression(SqStack *C);
//自带输入的四则运算 
datatype EvaluateExpression();
//判断优先级 
chartype Precede(chartype a,chartype b);
//对相关运算进行封装，返回运算结果 
datatype Operate(datatype a,chartype b,datatype c);
读取算数表达式
//获取表达式 
void GetExpression(SqStack *&S)
{
	cout<<"请输入运算代数式：";
	char ch=0;
	ch = getchar();
	while (ch !='\n') 
	{
		if(CharOrNot(ch))//为字符 
		{
			Push(S,ch);
			ch = getchar();
		}
		else 
		{
			datatype k=1;
			datatype m=datatype(ch)-48;
			ch = getchar();
			while(ch!='.' && !CharOrNot(ch))
			{
				m=m*10+int(ch)-48;
				ch = getchar();
			}
			if(ch=='.') ch=getchar();
			while(!CharOrNot(ch))	
			{
				k=0.1*k;
				m=m+k*(int(ch)-48);
				ch = getchar();
			}	
			Push(S,m);
		}
	}
}
转换算数式顺序-出栈进栈

按照输入顺序输出，方便进行运算

//变换顺序 
void ReturnStack(SqStack *&S)
{
	SqStack *Q;node *p;
	InitStack(Q);
	datatype a;chartype b;
	
	while(S->Top!=NULL)
	{
		p=S->Top;
		S->Top = p->next;
		p->next = Q->Top; 
		Q->Top=p;
	}
	S->Top = Q->Top;
	Q->Top = NULL;
	free(Q);
	cout<<"转变完成"<<endl;
}
判断优先级
//判断优先级 
chartype Precede(chartype a,chartype b)
{
	int m,n;
	switch(a)
	{
		case '#': m=0;break;
		case '-':
		case '+': m=2;break;
		case '*':
		case '/': m=3;break;
		case '(': m=1;break;
		//default
		//case')': m=3;
	}
	switch(b)
	{
		case '#': n=0;break;
		case '-':
		case '+': n=2;break;
		case '*':
		case '/': n=3;break;
		case '(': n=4;break;
		case ')': n=1;break;
		//default
	}

	if(m<n)
		a='<';
	else if(m==n && m == 1)//脱括号 
		a='=';
	else if(m==n &&m != 0 && m!= 1 || m>n)
		a='>';
		
	return a;
}
操作符运算
datatype Operate(datatype a,chartype b,datatype c)
{
	switch(b)
	{
		case'+':	return a+c;break;
		case'-':	return c-a;break;
		case'*':	return a*c;break;
		case'/':	return c/a;break;
	}
}
四则运算函数
datatype EvaluateExpression(SqStack *C)
{
	SqStack *S,*Q;node *p;
	InitStack(S);InitStack(Q);
	Push(Q,'#'); //作为结束判断的标志 
	chartype b='!';datatype a;datatype c; 
	//当最后一个和第一个元素都为#时结束 
	while(p->sign!='#' || b!='#')
	{
		ifcp->flag == 1)//flag = 1 为数字 
		{
			Push(S,p->num);p=p->next;//进入数字栈 
        }
		else if(p->flag == 2)  //为字符 
		{
			GetTop(Q,b);
			//通过switch判断需要做的操作 
			switch(Precede(b,p->sign)){
			case'<'://栈顶符号优先级小于当前符号 
					Push(Q,p->sign);//对当前进行进栈操作 
					p=p->next;//p指向下一个节点 
					break;
			case'='://脱括号 
					Pop(Q,b);//出栈 
					p=p->next;//p指向下一个节点 
					break;
			case'>':// 栈顶符号优先级大于当前符号 
					Pop(Q,b);//出栈操作符 
					Pop(S,a);//得到第二个数字
					Pop(S,c);//得到第一个数字
					Push(S,Operate(a,b,c));//将运算结c果进栈 
					break;
			}
		}
		GetTop(Q,b);//更新 b 为栈顶元素符号，方便判断 
	}
	GetTop(S,a);//结束循环，返回数字栈结果 
	SetNull(S);SetNull(Q);//置空 
	free(S);free(Q);free(p);//释放栈格式 
	
	return a;//返回结果 
}

附：自带读取功能的四则算法

无需读取算数表达式的操作，可直接调用

本文栈相关操作与之匹配

提供不同的思路方法

 //无需读取字符串算法 
/*datatype EvaluateExpression()
{
	SqStack *S,*Q;
	InitStack(S);InitStack(Q);
	Push(S,'#');Push(Q,'#'); 
	chartype b; chartype d; datatype a;datatype c; 
	cout<<"请输入运算代数式：";
	chartype ch=getchar();
	while(ch!='#' || b!='#')
	{
		if(!CharOrNot(ch))
		{
			a=datatype(ch);
			Push(S,a-48);
			ch=getchar();
		}
		else 
		{
			d = chartype(ch);GetTop(Q,b);
			switch(Precede(b,d)){
			case'<':
					Push(Q,ch);ch=getchar();break;
			case'=':
					Pop(Q,b);ch=getchar();break;
			case'>':
					Pop(Q,b);//操作符 
					Pop(S,a);//第一个数字
					Pop(S,c);//第二个数字
					Push(S,Operate(a,b,c));
					break;
			}
		}
		GetTop(Q,b); 
	}
	GetTop(S,a);
	SetNull(S);SetNull(Q);
	free(S);free(Q);
	
	return a;
 }

结果分析

基本的四则运算

带括号的运算

小数运算

在这里插入图片描述

负数运算

写道这里已经满足了上机需求，并且花费了许多时间用于调试和理解算法。之后有时间会添加上这一部分。

完整代码

main.cpp

#include "func.h"
int main()
{
	SqStack *S;
	InitStack(S);
	GetExpression(S);
	ReturnStack(S);
	datatype a;
	a = EvaluateExpression(S);
	cout<<"运算结果： "<<a<<endl;
	SetNull(S);
	free(S);
	return 0;
}

func.h


#include<iostream>
#include <stdlib.h>
using namespace std;
typedef float datatype;
typedef char chartype;
#define MaxSize 30

//定义栈格式 
typedef struct node
{
	int flag; //标记位，1为浮点数，2为字符型 
	datatype num;
	chartype sign;
	node* next;
}node;

typedef struct Sqstack
{
	node *Top;
}SqStack;

//构造一个空栈 
void InitStack(SqStack *& S);

//置空栈
void SetNull(SqStack *S); 

//判断栈空
int Empty(SqStack*S);

//出栈 
void Pop(SqStack *S,datatype &e);
void Pop(SqStack *S,chartype &e);
//入栈 
void Push(SqStack *S,datatype n);
void Push(SqStack *S,chartype s);
//
void GetTop(SqStack *S,datatype &e);
void GetTop(SqStack *S,chartype &e);
//判断是否为字符型，是返回1，否返回0 
int CharOrNot(char ch); 
//输入表达式保存 
void GetExpression(SqStack *&S);
//输入输出对换 
void ReturnStack(SqStack *&S);
//四则运算 
datatype EvaluateExpression(SqStack *C);
//自带输入的四则运算 
datatype EvaluateExpression();
//判断优先级 
chartype Precede(chartype a,chartype b);
//对相关运算进行封装，返回运算结果 
datatype Operate(datatype a,chartype b,datatype c);

func.cpp

#include "func.h" 
//构造一个空栈 
void InitStack(SqStack *& S)
{
	S = (SqStack*)malloc(sizeof(SqStack));
	S->Top = NULL;
}

//置空栈
void SetNull(SqStack *S)
{
	node* p = NULL;
	while(S->Top != NULL)
	{
		p = S->Top;
		S->Top = p->next;
		free(p);p = NULL;
	} 
	cout<<"置空成功"<<endl;
}

//判断栈空,空返回1 
int Empty(SqStack*S)
{
	if(S->Top<=0) return 1;
	else return 0;
 } 

//入栈 
void Push(SqStack *S,datatype n)
{
	node *p = (node*)malloc(sizeof(node));
	if(p != NULL)
	{
		p->flag = 1;
		p->num = n;
		p->next = S->Top;
		S->Top = p;
		//cout<<"Num入栈成功:"<<p->num<<endl;
	}
	else 
		cout<<"Error"<<endl;
}
//入栈 
void Push(SqStack *S,chartype s)
{
	node *p = (node*)malloc(sizeof(node));
	if(p != NULL)
	{
		p->flag = 2;
		p->sign = s;
		p->next = S->Top;
		S->Top = p;
		//cout<<"Sign入栈成功:"<<p->sign<<endl;
	}
	else 
		cout<<"Error"<<endl;
}

//出栈 
void Pop(SqStack *S,datatype &e)
{
	if(S->Top != NULL)
	{
		node* p = S->Top;
		e = p->num;
		S->Top = p->next;
		free(p);
		//cout<<"出栈成功: "<<e<<endl;
	}
	else {}
}
void Pop(SqStack *S,chartype &e)
{
	if(S->Top != NULL)
	{
		node* p = S->Top;
		e = p->sign;
		S->Top = p->next;
		free(p);
		//cout<<"出栈成功: "<<e<<endl;
	}
	else {}
}

//获得栈顶元素 
void GetTop(SqStack *S,chartype &e)
{
	if(S->Top != NULL)
		e = S->Top->sign;
	else {}
}
void GetTop(SqStack *S,datatype &e)
{
	if(S->Top != NULL)
		e = S->Top->num;
	else {}
}

//判断运算符 为真返回1
int CharOrNot(char ch)
{
	if(ch!='+'&&ch!='-'&&ch!='*'&&ch!='/'&&ch!='('&&ch!=')'&&ch!='#')
	return 0;
	else return 1;
} 
//获取表达式 
void GetExpression(SqStack *&S)
{
	cout<<"请输入运算代数式：";
	char ch=0;
	ch = getchar();
	while (ch !='\n') 
	{
		if(CharOrNot(ch))//为字符 
		{
			Push(S,ch);
			ch = getchar();
		}
		else 
		{
			datatype k=1;
			datatype m=datatype(ch)-48;
			ch = getchar();
			while(ch!='.' && !CharOrNot(ch))
			{
				m=m*10+int(ch)-48;
				ch = getchar();
			}
			if(ch=='.') ch=getchar();
			while(!CharOrNot(ch))	
			{
				k=0.1*k;
				m=m+k*(int(ch)-48);
				ch = getchar();
			}	
			Push(S,m);
		}
	}
	cout<<"输入完毕"<<endl; 
}

//变换顺序 
void ReturnStack(SqStack *&S)
{
	SqStack *Q;node *p;
	InitStack(Q);
	datatype a;chartype b;
	
	while(S->Top!=NULL)
	{
		p=S->Top;
		S->Top = p->next;
		p->next = Q->Top; 
		Q->Top=p;
	}
	S->Top = Q->Top;
	Q->Top = NULL;
	free(Q);
	cout<<"转变完成"<<endl;
}

//输入栈 处理 
datatype EvaluateExpression(SqStack *C)
{
	SqStack *S,*Q;node *p;
	InitStack(S);InitStack(Q);
	Push(Q,'#'); //作为结束判断的标志 
	chartype b='!';datatype a;datatype c; 
	//当最后一个和第一个元素都为#时结束 
	while(p->sign!='#' || b!='#')
	{
		if(p->flag == 1)//flag = 1 为数字 
		{
			Push(S,p->num);p=p->next;//进入数字栈 
		}
		else if(p->flag == 2)  //为字符 
		{
			GetTop(Q,b);
			//通过switch判断需要做的操作 
			switch(Precede(b,p->sign)){
			case'<'://栈顶符号优先级小于当前符号 
					Push(Q,p->sign);//对当前进行进栈操作 
					p=p->next;//p指向下一个节点 
					break;
			case'='://脱括号 
					Pop(Q,b);//出栈 
					p=p->next;//p指向下一个节点 
					break;
			case'>':// 栈顶符号优先级大于当前符号 
					Pop(Q,b);//出栈操作符 
					Pop(S,a);//得到第二个数字
					Pop(S,c);//得到第一个数字
					Push(S,Operate(a,b,c));//将运算结果进栈 
					break;
				}
		}
		GetTop(Q,b);//更新 b 为栈顶元素符号，方便判断 
	}
	GetTop(S,a);//结束循环，返回数字栈结果 
	SetNull(S);SetNull(Q);//置空 
	free(S);free(Q);free(p);//释放栈格式 
	
	return a;//返回结果 
} 
 
 //无需读取字符串算法 
/*datatype EvaluateExpression()
{
	SqStack *S,*Q;
	InitStack(S);InitStack(Q);
	Push(S,'#');Push(Q,'#'); 
	chartype b; chartype d; datatype a;datatype c; 
	cout<<"请输入运算代数式：";
	chartype ch=getchar();
	while(ch!='#' || b!='#')
	{
		if(!CharOrNot(ch))
		{
			a=datatype(ch);
			Push(S,a-48);
			ch=getchar();
		}
		else 
		{
			d = chartype(ch);GetTop(Q,b);
			switch(Precede(b,d)){
			case'<':
					Push(Q,ch);ch=getchar();break;
			case'=':
					Pop(Q,b);ch=getchar();break;
			case'>':
					Pop(Q,b);//操作符 
					Pop(S,a);//第一个数字
					Pop(S,c);//第二个数字
					Push(S,Operate(a,b,c));
					break;
			}
		}
		GetTop(Q,b); 
	}
	GetTop(S,a);
	SetNull(S);SetNull(Q);
	free(S);free(Q);
	
	return a;
 } 
*/

//判断优先级 
chartype Precede(chartype a,chartype b)
{
	int m,n;
	switch(a)
	{
		case '#': m=0;break;
		case '-':
		case '+': m=2;break;
		case '*':
		case '/': m=3;break;
		case '(': m=1;break;
		//default
		//case')': m=3;
	}
	switch(b)
	{
		case '#': n=0;break;
		case '-':
		case '+': n=2;break;
		case '*':
		case '/': n=3;break;
		case '(': n=4;break;
		case ')': n=1;break;
		//default
	}

	if(m<n)
		a='<';
	else if(m==n && m == 1)//脱括号 
		a='=';
	else if(m==n &&m != 0 && m!= 1 || m>n)
		a='>';
		
	return a;
}

datatype Operate(datatype a,chartype b,datatype c)
{
	switch(b)
	{
		case'+':	return a+c;break;
		case'-':	return c-a;break;
		case'*':	return a*c;break;
		case'/':	return c/a;break;
	}
	
}
Duder-Curcle
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt之加减乘除四则运算-支持负数
07-23
C++版本的四则运算事例，支持负数，表达式中可以含有空格，讲解文章：https://www.cnblogs.com/swarmbees/p/9356346.html
保留两位及两位以内的非负小数
jiandan1127的博客
10-22 686
function keepTwo(obj){ obj.value = obj.value.replace(/[^\d.]/g,""); //清除“数字”和“.”以外的字符 obj.value = obj.value.replace(/\.{2,}/g,"."); //只保留第一个. 清除多余的 obj.value = obj.value.replace(".","$...
c语言利用栈实现四则运算(包括括号小数),<DataStructure_1>用栈实现四则运算(c语言)...
weixin_35831256的博客
05-22 846
有一句计算机界中的至理名言:程序=数据结构+算法可见数据结构是多么地重要啊......呵呵今天开始复习了一下数据结构 , 解决了以前的一个问题:用栈这个数据结构实现四则运算算法思想是借鉴了<>(清华大学出版社 严蔚敏)中的一些思想 , 最原始的算法就是波兰一位逻辑学家的逆波兰表示法也就是讲中缀表达式转为后缀表达式的算法 , 感觉很强大 , 呵呵......好了F话就不多说了 , 直接...
映射与函数（二）
咔咔响
05-22 815
1.函数是实数域到实数域的一种特殊的映射2.常数函数、幂函数、指数函数、对数函数、三角和反三角函数是六种基本初等函数3.由基本初等函数经过有限次四则运算和复合运算所产生的函数称为初等函数4...
C++版本计算机实现，支持小数、负数运算
09-10
运行环境：VS2015，没有环境可以把代码复制出来用 支持小数，支持负数运算
js实现随机的四则运算题目效果
01-20
本文主要介绍了随机的四则运算题目，这样就可以自动的生成随机的30个四则运算题目了。可以生成随机的四则运算题目给给小学生用，但是还是有问题，小学生啊！他们不知道负数，不知道小数。所以还要加入判定条件。具体...
小学四则运算生成器
12-22
小学四则运算生成器,如题,软件是为了大大方便家长对孩子进行数学联系训练而编写的软件,是小学数学多功能出题器的简化版.出题后保存为txt文件,可以直接打开TXT文件打印在纸上.详情请自行下载.
四则运算计算器V3_C语言项目
04-11
支持括号、小数、长数字、异常输入规避和判断。修复 V2版本中存在的错误；新增 精确到小数点后两位的浮点计算；新增 输出后缀表达式；优化 输入输出数据范围；优化 在括号内输入单个数字的运算。程序可运行测试和...
高精度（非负数的加减乘除）
山外青山明月楼的博客
02-07 450
高精度（非负数的加减乘除） 高精度的几种情况： A + B, A - B, A * b, A / b; 其中数据范围一般为A,B <= len(1e6), b <= 1e4。 1.高精度加法： 题目791： 给定两个非负整数，计算它们的和。 输入格式 共两行，每行包含一个整数。 输出格式 共一行，包含所求的和。 数据范围 1≤整数长度≤100000 输入样例： 12 23 输出样例： 35 #include<iostream> #include<vector> usin
js中取小数整数部分函数
weixin_30877755的博客
06-08 185
1.丢弃小数部分,保留整数部分 js:parseInt(7/2) 2.向上取整,有小数就整数部分加1 js: Math.ceil(7/2)3,四舍五入.js: Math.round(7/2)4,向下取整js: Math.floor(7/2)附：如何判断输入的数值类型（使用时不带引号！） "^\\d+$"　　//非负整数（正整数 + 0） "^[0-9]*[1-9][...
数据结构第二次作业（表达式求值【栈模拟】）
热门推荐
_Somethingwill
10-06 1万+
实验题目：栈的应用－算术表达式求值                                        　 实验目的 ： 1 ．掌握栈的定义及实现； 2 ．掌握利用栈求解算术表达式的方法。 实验内容： 通过修改完善教材中的算法3.4，利用栈来实现算术表达式求值的算法。对算法3.4中调用的几个函数要给出其实现过程： (1)
链式栈实现四则运算，表达式可包含括号，可计算小数
qq_45414669的博客
02-06 580
由于代码中的注释已较为详尽，在此就只贴代码了 ExprCPro.cpp #include "pch.h" #include"Expr.h" #include <iostream> using namespace std; int main() { cout << "-------------表达式求值--------------" <&l...
C++学习 八、函数
qq_41035283的博客
02-03 598
C++学习 八、函数前言函数使用函数声明（函数原型）函数定义函数调用函数参数，按值传递传值传址函数与数组函数与字符串函数与结构体默认参数内联函数 前言 本片继续学习C++，函数。 函数使用 函数是C++的基本编程模块，以便于程序的模块化和代码复用。 函数声明（函数原型） 要使用函数，首先要提供函数原型，即声明函数，格式为 TypeName FuncName (Parameters) 即 返回值类型 函数名 （参数列表） 函数原型为编译器提供了函数名，函数返回值类型，参数类型和数量，用以编译器检查和处理。下面
栈与队列--置空/销毁-栈/队列
了不起的阿港的博客
06-28 5338
数组栈 完成void MakeEmpty(Stack S)函数，该函数把栈置空(但不释放空间)。 完成Stack DisposeStack(Stack S)函数，该函数销毁数组栈(释放数组空间与栈空间)，返回NULL指针。typedef int ElemType; struct StackRecord; typedef struct StackRecord *Stack; struct Stac
堆和栈，null和‘‘的区别以及使用
liulang68的博客
08-16 323
堆的生命周期: https://blog.csdn.net/qq_40959340/article/details/84486794 堆和栈的理解：Java虚拟机的堆、栈、堆栈如何去理解？ - Gilgamesh的回答 - 知乎 https://www.zhihu.com/question/29833675/answer/45831313 Java虚拟机的堆、栈、堆栈如何去理解？ - EnjoyMoving的回答 - 知乎 https://www.zhihu.com/question/29833675/an
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 620
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
C语言.动态内存管理
最新发布
Joseit的博客
05-16 590
栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收。分配方式类似于链表。数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
使用java实现小数，三角函数，正数的四则运算
02-20
使用Java实现小数，三角函数和正数的四则运算可以通过使用Java中的数学函数实现，例如Math.add()、Math.subtract()、Math.multiply()和Math.divide()。此外，还可以使用Java的BigDecimal类实现小数的四则运算。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值