atoi（ascii to integer），把字符串转换成整型数
 
函数原型
 
int atoi(const char *nptr) 
 
函数说明
 ① 函数会扫描参数 nptr字符串，会跳过前面的空白字符（例如空格，tab缩进）等；
 ② 如果 nptr不能转换成 int 或者 nptr为空字符串，那么将返回 0；
 ③ atoi输入的字符串对应数字存在大小限制（与int类型大小有关），若其过大可能报错-1
 
代码举例
 
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
    int n;
    char *str = "12345.67";
    n = atoi(str);
    printf("n=%d\n",n);
    return 0;
}
 
结果：n = 12345
 
#include <stdlib.h>
#include <stdio.h>
int main()
{
    char a[] = "-100";
    char b[] = "123";
    int c;
    c = atoi(a) + atoi(b);
    printf("c=%d\n", c);
    return 0;
}
 
执行结果：c = 23

atoi
 
先来看看官方文档（传送门）
 
接口
 
int atoi (const char * str);
 
Convert string to integer
 
Parses the C-string str interpreting its content as an integral
 number, which is returned as a value of type int.
The function first discards as many whitespace characters (as in
 isspace) as necessary until the first non-whitespace character is
 found. Then, starting from this character, takes an optional initial
 plus or minus sign followed by as many base-10 digits as possible,
 and interprets them as a numerical value.
The string can contain additional characters after those that form
 the integral number, which are ignored and have no effect on the
 behavior of this function.
If the first sequence of non-whitespace characters in str is not a
 valid integral number, or if no such sequence exists because either
 str is empty or it contains only whitespace characters, no conversion
 is performed and zero is returned.
 
Parameters
 
C-string beginning with the representation of an integral number.
 
Return Value
 
On success, the function returns the converted integral number as an
 int value.
If the converted value would be out of the range of representable
 values by an int, it causes undefined behavior. See strtol for a more
 robust cross-platform alternative when this is a possibility.
 
说了折磨多还是用代码验证验证吧
 
int main() {
	//模拟实现atoi
	char str[] = "-22675";
	int ans = atoi(str);
	printf("%d\n",ans);
	system("pause");
	return 0;
}
 
运行结果：-22675
 
int main() {
	//模拟实现atoi
	char str[] = "   -22675";// 添加空格
	int ans = atoi(str);
	printf("%d\n",ans);
	system("pause");
	return 0;
}
 
运行结果：-22675
 
int main() {
	//模拟实现atoi
	char str[] = "   +22675";
	int ans = atoi(str);
	printf("%d\n",ans);
	system("pause");
	return 0;
}
 
运行结果：22675
 
int main() {
	//模拟实现atoi
	char str[] = " ww  +22675";
	int ans = atoi(str);
	printf("%d\n",ans);
	system("pause");
	return 0;
}
 
运行结果：0
 
int main() {
	//模拟实现atoi
	char str[] = "   +22675wer";
	int ans = atoi(str);
	printf("%d\n",ans);
	system("pause");
	return 0;
}
 
运行结果：22675
 
试了折磨多大家1应该也发现了他的功能了。下来就自己实现atoi
 
C语言实现
 
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<assert.h>
#include<windows.h>



int my_atoi(const char * str) {
	assert(str);
	int j = 0;
	while (str[j] != '\0') {
		// 将字符串前边的空格跳过
		while (str[j] != '\0' && str[j] == ' ') {
			j++;
		}
		//如果出现+  -  或者数字就结束循环，否则返回0
		if (str[j]!='+' && str[j] != '-' && (str[j]<'0' ||str[j]>'9')) {
			return 0;
		}
		break;	
	}
	
	// 程序走到这里说明开头是+123  或者-123类似开头
	int ans = 0;
	int tmp = 1;
	// 对 +  - 处理一下，利用tmp标记+  -
	if (str[j] == '+') {
		j++;
		
	}
	if (str[j] == '-') {
		tmp = -1;
		j++;
	}
	int count = 0;
	// 处理数字
	while (str[j] != '\0'&& str[j] >='0' &&str[j]<='9') {
		//printf("%d", pow(10, count));
		ans += pow(10,count)*(str[j] - '0');
		count++;
		j++;
	}
	int num = 0;
	// 反转一下
	while (ans) {
		num += pow(10, --count)*(ans % 10);
		ans = ans / 10;
	}
	return num*tmp;

}

int main() {
	//模拟实现atoi
	char str[] = "   +22675wer";
	int ans = my_atoi(str);
	printf("%d\n",ans);
	system("pause");
	return 0;
}

1、atoi()解析
 
atoi()原型: int atoi(const char *str );
 
函数功能：把字符串转换成整型数。
 
参数str：要进行转换的字符串
 
返回值：每个函数返回 int 值，此值由将输入字符作为数字解析而生成。 如果该输入无法转换为该类型的值，则atoi的返回值为 0。
 
工作原理：atoi通过全局变量来区分返回0的情况。
 如果是非法输入，返回0，并把这个全局变量设为特殊标志；
 如果输入是”0”，则返回0，不会设置全局变量。
 
注意：使用该函数时要注意atoi返回的是int类型，注意输入str的范围不要超出int类型的范围。
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
	int a;
 
	char *ptr1 = "3124";
	char *ptr2 = "0";
	char *ptr3 = "12.33";
	char *ptr4 = "-1245";
	char *ptr5 = "+21";
	char *ptr6 = "s3241";
 
	a = atoi(ptr1);
	printf("\"%s\"\t-> %d\n",ptr1, a);
 
	a = atoi(ptr2);
	printf("\"%s\"\t-> %d\n",ptr2, a);
 
	a = atoi(ptr3);
	printf("\"%s\"\t-> %d\n",ptr3, a);
 
	a = atoi(ptr4);
	printf("\"%s\"\t-> %d\n",ptr4, a);
 
	a = atoi(ptr5);
	printf("\"%s\"\t-> %d\n",ptr5, a);
 
	a = atoi(ptr6);
	printf("\"%s\"\t-> %d\n",ptr6, a);
 
	return 0;
}
 
打印如下：
 
"3124"     -> 3124
"0"           -> 0
"12.33"    -> 12
"-1245"    -> -1245
"+21"       -> 21
"s3241"    -> 0
 
2、atoi()函数缺陷分析
 
从上述打印能够看出来，要是首字母是非法字母，及无法转换的类型，是输出为0的。这可能会造成灾难性的结果，因为不知道输入的是0，字符串还是非法字符串。
 
解决方案：可以加一个传参(变量)和主函数中switch语句判断转化错误的原因。（更好的解决方案）
 
比如工控上钻头移动坐标(x,y,z)。x，y，z三个坐标是靠服务器下发下来，若程序错误，传入了一个错误的结果(s12,3,4)(以字符串形式下发)，如果直接调用atoi，必然解析成(0,3,4)，移动到了错误的位置！
 
当然可以对输入的字符串进行检查，可为啥不在atoi里面检查呢？
 
3、aioi()函数改造
 
/*
用法：将字符串里的数字字符转化为整形数。并返回处理的字符个数。
注意：转化时跳过前面的空格等空字符，直到遇上数字或正负符号才开始做转换，
而再遇到非数字或字符串结束标志('/0')才结束转换，并将结果返回。
目的是改造atoi函数
处理失败或者没有整型字符串则返回0，处理成功发回处理字符串的个数
*/
int CM_Atoi(char* source,int* integer)//为了在被调用函数中修改其无法直接访问的实参的值
{
	int offset1,offset2,num;
	int signedflag;//+为1 -为0
 
	if(source == NULL || *source == '\0' ||integer == NULL)
	{
		return 0;
	}
 
	offset1 = 0;//记录处理正负号的个数
	offset2 = 0;//记录处理数字的个数
	num = 0;
 
	while(*source > 0 && *source <= 32)//去除首部空格 \r \n \t \r 等异常字符,ASCII码值是32(含义为空格)，ASCII码值是0(含义为空字符)。
	{
		source++;
		offset1++;
	}
 
	signedflag = 1;//默认为+
	if(*source == '+')
	{
		signedflag = 1;
		source++;
		offset1++;
	}
	else if(*source == '-')
	{
		signedflag = 0;
		source++;
		offset1++;
	}
 
	while(*source != '\0' && *source >= '0' && *source <= '9')
	{
		num = *source- '0' + num*10;
		source++;
		offset2++;
		if (num < 0)//整数溢出的情况，若溢出肯定变为负数
		{
			*integer = 0;
			return 0;
		}
	}
 
	if(signedflag == 0)
	{
		num = 0 - num;
	}
 
	if(offset2)
	{
		*integer = num;
		return offset1+offset2;
	}
	else
	{
		return 0;
	}
}
 
转发的整型已指针带入，返回转换的成功的字符串个数，应用层对CM_Atoi（）函数返回值做检查，若返回为0，则比如转换失败，大于0，才成功转换成功。
 
4、atof()函数改造
 
同样方法对atof进行改造
 
/*
简单的x的y次幂
*/
long long pow1(int x,int y)
{
	long long num = 1;
	int i;
 
	for(i = 0; i < y; i++)
	{
		num = num*x;
	}
 
	return num;
}
 
/*
用法：将字符串里的数字字符转化为浮点型。并返回处理的字符个数。
注意：转化时跳过前面的空格等空字符，直到遇上数字或正负符号才开始做转换，
而再遇到非数字或字符串结束时('/0')才结束转换，并将结果返回。
目的是改造atof函数
处理失败或者没有浮点型字符串则返回0
支持正负号
*/
 
int CM_Atof(char* source,double* doubleing)
{
	int offset1,offset2,n;
	double num;
	int signedflag;//+为1 -为0
 
	if(source == NULL || *source == '\0' || doubleing == NULL)
	{
		return 0;
	}
 
	offset1 = 0;
	offset2 = 0;
	num = 0.0;
 
	while(*source > 0 && *source <= 32)//去除首部空格 \r \n \t \r 等异常字符,ASCII码值是32(含义为空格)，ASCII码值是0(含义为空字符)。
	{
		source++;
		offset1++;
	}
 
	signedflag = 1;//默认为+
	if(*source == '+')
	{
		signedflag = 1;
		source++;
		offset1++;
	}
	else if(*source == '-')
	{
		signedflag = 0;
		source++;
		offset1++;
	}
 
 
	//整数部分
	while(*source != '\0' && *source >= '0' && *source <= '9')
	{
		num = *source- '0' + num*10.0;
		source++;
		offset2++;
		if (num < 0)//整数溢出的情况，若溢出肯定变为负数
		{
			*doubleing = 0;
			return 0;
		}
	}
 
	if(offset2 != 0 && *source == '.')
	{
		source++;
		offset2++;
 
		//小数部分
		n = 0;
		while(*source != '\0' && *source >= '0' && *source <= '9')
		{
			num = (*source- '0')*(1.0/pow1(10,++n)) + num;
			source++;
			offset2++;
		}
	}
 
	if(signedflag == 0)
	{
		num = -num;
	}
 
	if(offset2)
	{
		*doubleing = num;
		return offset1 + offset2;
	}
	else
	{
		return 0;
	}
}
 
————————————————
 原文链接：https://blog.csdn.net/dingzj2000/article/details/89277497

大家好，这是我第10篇文章
 

之前在敲一份代码的时候，发现了一个问题
 
#include<iostream>
#include<stdlib.h>
using namespace std;
int main(int argc,char* argv[])
{
	int a,b,c,v;
	a=atoi(argv[1]);
	b=atoi(argv[1]);
	v=a+b;
	cout<<"/n输入第一个数："<<a<<endl; 
	cout<<"/n输入第二个数："<<b<<endl;
	cout<<a<<"+"<<b<<"="<<c<<endl;
	return 0; 
}
 
你们有没有考虑到atoi有什么作用，我刚开始也没想到，直达被朋友反问了一下，才上网查找了一下atoi函数的作用，刚开始疑惑的是a是整形变量，argv是字符变量，两者怎么相等，怎么联系在一起
 
a=atoi(argv[1]);
 
原来是atoi函数的作用，atoi()函数的功能：将字符串转换成整型数；atoi()会扫描参数char字符串，跳过前面的空格字符，直到遇上数字或正负号才开始做转换，而再遇到非数字或字符串时（’\0’）才结束转化，并将结果返回（返回转换后的整型数）。
 argv[]是个字符数组，与整形进行转化
 
如图所示
 
#include<iostream>
#include<stdlib.h>
using namespace std;
int main(void)
{
 int v;
char a='h';
char *b="16987";

v=atoi(b);

cout<<a<<b<<v<<endl;
return 0;
}
 
注意：字符串可以为数字（数字也是字符）
 
运用到atoi函数的时候一定用到指针，用指针获得地址，进行转化
 
运行后，你可以发现整形v可以输出char的字符串，这就是atoi函数的作用
 

希望各位能够一键三连，多谢多谢