26.【C语言】字符串转无符号整型unsignedint、字符串转有符号整型int、无符号整型unsignedint转字符串、有符号整型转字符串（5_task）

算法思想：
1. 字符串转无符号整型unsignedint
初始化一个字符串str；num用于存放当前转换的整型数，初始化为0。对字符串str中的每个字符进行判断，一旦扫描到当前字符在数字字符的范围之外，直接跳出循环。那么转换的整型数是由从串首开始，一直到不为数字字符或为结束符为止形成的一段纯数字字符。若在数字字符的范围之内，当前num为上一次转换的num乘10，再加上当前字符与字符‘0’的ASCII值的差值。其实当前字符转换成的整型数值就是当前字符的ASCII值减去‘0’的ASCII值。每一次把对应的字符转换后，字符指针str就向后偏移一个字符位置。因为是字符串转换成整型数，得到的是一个整型数值，那么该函数为返回值的int类型。

函数实现代码如下：

int unsignedstrtoint(char *str)		//开头不带正负号的字符串转整型
{
	int num = 0;
	if (NULL == *str)	//字符串为空
		return 0;
	else {
		while (str)
		{
			if (*str<'0' || *str>'9')		//只要当前字符不在数字字符的范围内，直接跳出循环
				break;
			else
				num = num * 10 + (*str - '0');		//括号里面的是二者字符对应ASCII值的差值，即为当前位置的字符对应的整型值
			str++;
		}
	}
	return num;
}

2. 字符串转有符号整型int
该函数的思路和字符串转无符号整型unsignedint主体相同，不同的是需要判断字符串串首是‘+’，还是数字字符，还是‘-’。前两种表示正数形式，后一种为负数形式。如果串首是‘+’或‘-’，那么字符指针就向后移1个字符位置，然后做相应处理，否则直接做相应处理。最后如果串首为‘-’，那么函数返回num的相反数。因为还是字符串转换成整型数，得到的是一个整型数值，那么该函数为返回值的int类型。

函数实现代码如下：

int strtoint(char *str)		//开头不带正负号的字符串转整型
{
	int num = 0;
	short flag;		//用于标记转换后整型的符号
	if (NULL == *str)	//字符串为空
		return 0;
	else if ('-' == *str)
	{
		flag = 1;
		str++;
	}
	else if ('+' == *str)
	{
		flag = 0;
		str++;
	}
	else
		flag = 0;
	while (str)
	{
		if (*str<'0' || *str>'9')		//只要当前字符不在数字字符的范围内，直接跳出循环
			break;
		else
			num = num * 10 + (*str - '0');		//括号里面的是二者字符对应ASCII值的差值，即为当前位置的字符对应的整型值
		str++;
	}
	if (flag)
		num = (-1)*num;
	return num;
}

3. 无符号整型unsignedint转字符串
整型数转字符串就和上述的做法相反。无符号整型数unsignedint的取值范围为0~65535，那么字符串就需要用大小为6的字符数组c存放。用变量num存放整型数。num%10得到当前num的个位，这个数再加上‘0’的ASCII值就得到num的个位所代表字符的ASCII值，装入字符数组c。此时num还需要减去个位数值，再除10，这样原先num的十位变成现在的个位。便于下一次重复操作。同时用变量i记录放在字符数组中的位置下标。直到num为0，整型数的每一位读取结束，此时i为字符串长度。打印字符数组c会发现整型数的每一位在数组中的顺序是倒着放的。所以还需要将字符数组逆置。逆置的实现可以用两个变量low、high，分别表示数组的第一个位置下标和最后一个位置下标，这两个下标，一个向后移，一个向前移，对应指向的元素交换位置，直到low>high为止，逆置完成。最后将数组c得到的字符串传给第二个形参。
这个函数是无返回值的void类型，得到的是数组。假设这个函数为返回字符数组的指针类型，返回值是一个指针，那么在调用该函数的位置需要定义一个字符指针s，放着这个函数内部字符数组c的起始地址。一旦这个函数执行结束，指针c的地址就会释放，那么s指向的内容为空。所以该做法不可取。
调用该函数前需要初始化一个大小为6的字符数组，然后将该数组的字符串给该函数的第二个形参s，指针s传递的是一个字符数组的起始地址。

函数实现代码如下：

void unsignedinttostr(int num,char *s)		//调用该函数前事先初始化一个大小为6的字符数组，第二个形参是该数组的指针
{
	char c[6];		//无符号整型int的范围是0~65535，c[5]放结束符
	int i = 0;
	memset(c, 0, sizeof(c));
	while (num)
	{
		c[i] = num % 10 + '0';
		num = (num - num % 10) / 10;
		i++;
	}		//循环结束i=5
	int low = 0, high = i - 1;		//c[0]~c[4]这部分的字符串逆置
	while (low <= high)
	{
		char temp = c[low];
		c[low] = c[high];
		c[high] = temp;
		low++;
		high--;
	}
	strcpy(s, c);
}

4. 有符号整型转字符串
该函数的思路和无符号整型unsignedint转字符串主体相同，不同的是需要判断需要判断整型数num 的正负。无符号整型数unsignedint的取值范围为-32768~+32768，那么字符串就需要用大小为7的字符数组c存放，c[0]存放整型数的正负号。在将数组c逆置的时候，逆置的是c[1]-c[5]这一段字符串。其余做法和无符号整型unsignedint转字符串相同。
调用该函数前需要初始化一个大小为7的字符数组，然后将该数组的字符串给该函数的第二个形参s，指针s传递的是一个字符数组的起始地址。
函数实现代码如下：

void inttostr(int num,char *s)		//该函数在使用时事先初始化一个大小为7的字符数组，第二个形参是该数组的指针
{
	char c[7];		//有符号整型int的范围是-32767~+32767，c[0]放符号，c[6]放结束符
	memset(c, 0, sizeof(c));
	if (num >= 0)
		c[0] = '+';
	else
		c[0] = '-';
	int i = 1;			//从c[1]开始操作
	num = abs(num);
	while (num)
	{
		c[i] = num % 10 + '0';
		num = (num - num % 10) / 10;
		i++;
	}		//循环结束i=6
	int low = 1, high = i - 1;		//c[1]~c[5]这部分的字符串逆置
	while (low <= high)
	{
		char temp = c[low];
		c[low] = c[high];
		c[high] = temp;
		low++;
		high--;
	}
	strcpy(s, c);
}

完整代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int unsignedstrtoint(char *str)		//开头不带正负号的字符串转整型
{
	int num = 0;
	if (NULL == *str)	//字符串为空
		return 0;
	else {
		while (str)
		{
			if (*str<'0' || *str>'9')		//只要当前字符不在数字字符的范围内，直接跳出循环
				break;
			else
				num = num * 10 + (*str - '0');		//括号里面的是二者字符对应ASCII值的差值，即为当前位置的字符对应的整型值
			str++;
		}
	}
	return num;
}

void unsignedinttostr(int num,char *s)		//调用该函数前事先初始化一个大小为6的字符数组，第二个形参是该数组的指针
{
	char c[6];		//无符号整型int的范围是0~65535，c[5]放结束符
	int i = 0;
	memset(c, 0, sizeof(c));
	while (num)
	{
		c[i] = num % 10 + '0';
		num = (num - num % 10) / 10;
		i++;
	}		//循环结束i=5
	int low = 0, high = i - 1;		//c[0]~c[4]这部分的字符串逆置
	while (low <= high)
	{
		char temp = c[low];
		c[low] = c[high];
		c[high] = temp;
		low++;
		high--;
	}
	strcpy(s, c);
}

int strtoint(char *str)		//开头不带正负号的字符串转整型
{
	int num = 0;
	short flag;		//用于标记转换后整型的符号
	if (NULL == *str)	//字符串为空
		return 0;
	else if ('-' == *str)
	{
		flag = 1;
		str++;
	}
	else if ('+' == *str)
	{
		flag = 0;
		str++;
	}
	else
		flag = 0;
	while (str)
	{
		if (*str<'0' || *str>'9')		//只要当前字符不在数字字符的范围内，直接跳出循环
			break;
		else
			num = num * 10 + (*str - '0');		//括号里面的是二者字符对应ASCII值的差值，即为当前位置的字符对应的整型值
		str++;
	}
	if (flag)
		num = (-1)*num;
	return num;
}

void inttostr(int num,char *s)		//该函数在使用时事先初始化一个大小为7的字符数组，第二个形参是该数组的指针
{
	char c[7];		//有符号整型int的范围是-32767~+32767，c[0]放符号，c[6]放结束符
	memset(c, 0, sizeof(c));
	if (num >= 0)
		c[0] = '+';
	else
		c[0] = '-';
	int i = 1;			//从c[1]开始操作
	num = abs(num);
	while (num)
	{
		c[i] = num % 10 + '0';
		num = (num - num % 10) / 10;
		i++;
	}		//循环结束i=6
	int low = 1, high = i - 1;		//c[1]~c[5]这部分的字符串逆置
	while (low <= high)
	{
		char temp = c[low];
		c[low] = c[high];
		c[high] = temp;
		low++;
		high--;
	}
	strcpy(s, c);
}

int main() 
{
	printf("-----unsignedstrtoint---------\n");
	char *s1 = "12345";
	int num1 = unsignedstrtoint(s1);
	printf("%d\n", num1);
	
	printf("-----strtoint---------\n");
	char *s2 = "12345";
	int num2 = strtoint(s2);
	printf("%d\n", num2);
	
	char s3[] = "+12345";
	num2 = strtoint(s3);
	printf("%d\n", num2);
	
	char *s4 = "-12345";
	num2 = strtoint(s4);
	printf("%d\n", num2);
	
	printf("-----unsignedinttostr---------\n");
	int num3 = 12345;
	char s5[6];
	memset(s5, 0, sizeof(s5));
	unsignedinttostr(num3, s5);
	printf("%s\n", s5);

	printf("-----inttostr---------\n");
	int num4 = -12345;
	char s6[6];
	memset(s6, 0, sizeof(s6));
	inttostr(num4, s6);
	puts(s6);

	num4 = +12345;
	memset(s6, 0, sizeof(s6));
	inttostr(num4, s6);
	puts(s6);

	num4 = 12345;
	memset(s6, 0, sizeof(s6));
	inttostr(num4, s6);
	puts(s6);
	system("pause");
}

运行效果如下：