字符串与字节流的相互转化

在进行转化之前，我们需要清楚一个结论：
计算机存储字符是以ASCII码进行存储的，在转换时，要清楚如何从单个字符中使用原本ASCII值计算出对应的整数值大小？eg：

ASCII='c'-'0'

怎么理解呢？ASCII值等于当前存储的字符ASCII值减去0的ASCII值，得到另一个 ASCII值，这个值，就可以作为从字符串转为字节流的值大小，'0’的ASCII值为十六进制的0x30，如果’c’是字符6，则例子可以等于：

0x06=0x36-0x30

字符6对应的ASCII值为0x36，可计算得

字符串转为字节流（十进制字符串转换为整形字节流）

atoi实现原理：

isspace(int x)
{
 if(x==' '||x=='\t'||x=='\n'||x=='\f'||x=='\b'||x=='\r')
  return 1;
 else  
  return 0;
}
isdigit(int x)
{
 if(x<='9'&&x>='0')         
  return 1; 
 else 
  return 0;
 
}
int atoi(const char *nptr)
{
        int c;              
        int total;         
        int sign;           
        while ( isspace((int)(unsigned char)*nptr) )
            ++nptr;
        c = (int)(unsigned char)*nptr++;
        sign = c;          
        if (c == '-' || c == '+')
            c = (int)(unsigned char)*nptr++;   
        total = 0;
        while (isdigit(c)) {
            total = 10 * total + (c - '0');    
            c = (int)(unsigned char)*nptr++;    
        }
        if (sign == '-')
            return -total;
        else
            return total;  
}

ASCII表示的字符有128个，所以不存在最高位的讨论，针对最高位如何变换存储，前面的博客《C语言的位操作》有分析，各个转义字符可以百度。
一句话：就是软件构造出转字符流转字节流之前的算法

字节流转换为字符串（十进制整形字节流转为字符串）

源码实现原理：

void atoi(int n,char s[])  
{  
    int i,j,sign;  
  
    if((sign=n)<0)    //记录符号  
        n=-n;         //使n成为正数  
    i=0;  
    do{  
        s[i++]=n%10+'0';    //取下一个数字  
    }while((n/=10)>0);      //循环相除  
  
    if(sign<0)  
        s[i++]='-';  
    s[i]='\0';         
        printf("%s",s);  //生成的数字是逆序的，所以要逆序输出  
}  

改编，并正序输出到数组
倒序改编：

void _itoa(int b,char f[])//十进制字节流转化为字符串 
{
	int i=0;
	int j;
	int sign;
	if((sign=b)<0)
	{
		b=-b;
	}
	for(;;)
	{
		if(b>0)
		{
			f[i++]=b%10+'0';
		    b=b/10;
		}
		else
		{
			break;
		}
	}
	if(sign<0)
	{
		f[i++]='-';
	}
	f[i]='\0';
	printf("%s",f);//输出被转化为字符串存储的倒序序列
	str_put_upside_down(f);//下面的倒序处理函数
}

倒序处理函数

void str_put_upside_down(char f[]) 
{
	int i;
	int j;
	while(f[i]!='\0')
	{
		i++;
	} 
	printf("颠倒的字符串个数为：%d\r\n",i);
		for(j=0;j<i/2;j++)//
		{
			char a;
			a=f[i-j-1];
			f[i-j-1]=f[j];
			f[j]=a;
		} 
		printf("%s",f);

} 

输出效果：
传入的值如果整数值为：-123456（十进制整数）
倒序输出结果：“654321-”（字符串形式）
最终结果：“-123456”（字符串形式）

十六进制字符串转换为字节流

#define UNUSED(var) do { (void)var; } while(0)
int8_t HexStrToByte(uint8_t *dest, char *source, int32_t sourceLen)
{
    int32_t i;
    uint8_t highByte = 0, lowByte = 0;
    int32_t j = 0;

    UNUSED(j);
    UNUSED(highByte);
    UNUSED(lowByte);
    if (source == NULL || dest == NULL)
    {
        return -1;
    }
    /* 十六进制字符串转换为字节流  要求source字符数是偶数，单数不执行转换, */
    if (sourceLen % 2 != 0)
    {
       printf("HexStrToByte error,%d\r\n", sourceLen);
    }
    for (i = 0; i < sourceLen; i += 2)
    {
        highByte = _mkupper(source[i]);
        lowByte = _mkupper(source[i + 1]);
        if (highByte > 0x39)
            highByte -= 0x37;
        else
            highByte -= 0x30;
        if (lowByte > 0x39)
            lowByte -= 0x37;
        else
            lowByte -= 0x30;
        dest[i / 2] = (highByte << 4) | lowByte;
    }
    return 0;
}

eg：

char * b="123456ABDC";//必须为偶数个字符
char c[10];//目标存储空间
HexStrToByte（c,b,strlen(b)）;
输出结果：
c={0x12，0x34，0x56，0xAB，0xDC}；

总结

这些转换都是转换为原来存储的ASCII,比较与与之转换后真实数据的规律，得出他们之间的算法，照葫画瓢