字符串與字節流的相互轉化

在進行轉化之前，我們需要清楚一個結論：
計算機存儲字符是以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,比較與與之轉換後真實數據的規律，得出他們之間的算法，照葫畫瓢