C：数据相关操作

C数据相关操作

一、交换两个数据

方法二省去了中间变量。

1. 方法一

void SwapData(int &a,int &b)
{
	int temp=0
	temp = *a;
	*a = *b;
	*b = temp;
}

2.方法二

void SwapData(int &a,int &b)
{
	*a = *a+*b;
	*b = *a-*b;
	*a = *a-*b;
}

二、数组对称交换

输入：buf[]={1,2,3,4,5} 输出：buf[]={5,4,3,2,1}

/****************************************
 * @brief : 数组对称交换
 * @param : 输入数组
 * @param : 输入数据长度
 * @return: none
*****************************************/
void InversionArray(int *buff, int len)
{
    int i=0;
    for(i=0; i<len/2; i++)
    {
        buff[i] = buff[i] + buff[len-i-1];
        buff[len-i-1] = buff[i]-buff[len-i-1];
        buff[i] = buff[i] - buff[len-i-1];
    }
}

三、字符串对称交换

输入："abcdefg" 输出：gfedcba

/****************************************
 * @brief : 字符串对称交换
 * @param : 输入/输出 字符串
 * @return: true/false
*****************************************/
int InversionString(unsigned char *str)
{
	unsigned int i=0,len=0;
	if(str == NULL)
	{
		return false;
    }
    len=0;
    while (str[len] != '\0')
    {
        len++;
    }
    //注意：len为字符串的长度，但是下标是以str[0]开始计算
    //所以字符串最后一个有效数据为str[len-i-1]
	for(i=0; i<len/2; i++)
	{
		str[i] = str[i]+str[len-i-1];
		str[len-i-1] = str[i]-str[len-i-1];
		str[i] = str[i]-str[len-i-1];
	}
	return true;
}

四、数字转字符串

输入：int num=12234 输出："12234"

/****************************************
 * @brief : 数字转字符串
 * @param : 输入数字(long)
 * @param : 输出字符串
 * @return: true/false
*****************************************/
int NumberToString(long number, unsigned char *string)
{
    int i=0, j=0;
    if(number<0)            //判断是否为负数
    {
        number = -number;   //转换为正数
        *string = '-';      //增加负号
        string++;           //字符串向后移动
    }
	if(number==0)
	{
		*string = '0';
		*++string = '\0';
		return true;
	}
    while(number)           //按序写入字符串
    {
        string[j++] = number%10+'0';
        number /= 10;
    }
    for(; i<j/2; i++)         //对称交换
    {
        string[i] = string[i]+string[j-i-1];
        string[j-i-1] = string[i]-string[j-i-1];
        string[i] = string[i]-string[j-i-1];
    }
    string[j] = '\0';       //结尾增加结束符
    return true;
}

五、获取字符串中第一组数字

输入:char *string="abc1234de23f" 返回：(long)1234

/****************************************
 * @brief : 获取字符串中第一组数字
 * @param : 输入字符串
 * @return: 返回数字
*****************************************/
long StringToNumber(char *string)
{
    long number = 0;
    if(string == NULL)
    {
        return 0;
    }
    while (*string != '\0')
    {
        if(*string>='0' && *string<='9')
        {
            while ( (*string!='\0') && (*string>='0') && (*string<='9') )
            {
                number *= 10;
                number += *string-'0';
                string ++;
            }
            return number;
        }
        string++;
    }
    return 0;
}

六、数组转HEX字符串

输入：unsigned int buf[]={21150,11234,250,2};输出："529e 2be2 00fa 0002"

/***********************************************
 * @brief : 数组转HEX格式字符串
 * @param : 输入待转换的数组（可修改为8、16、32位数组）
 * @param : 数组长度
 * @param : 返回字符串指针
 * @param : HEX单位字节对齐方式
 * @return: false/true
************************************************/
int ArrayToHexString(unsigned int buf[], unsigned int len, unsigned char *string, char align)
{
    int i=0,j=0;
    if(string == NULL)
    {
        return false;
    }
    while (i < len)
    {
        //一个字节的数据用HEX表示，需要占用两个字节
        string += align*2;          //指针移到本次数据地址 尾部
        for(j=0; j<align*2; j++)    //从后往前写入HEX数据
        {
            string--;
            if( (buf[i]&0xF) < 10)
            {
                *string = (buf[i]&0xF)+'0';
            }
            else
            {
                *string = (buf[i]&0xF)-10+'a';
            } 
            buf[i] >>= 4;
        }
        string += align*2;  //指针再次移到本次数据地址 尾部
        *string = ' ';      //插入空格
        string++;           //插入空格地址需要往前移动
        i++;                
    }
    *string = '\0';         //添加结束符
    return true;
}

备注链接：

七、关于sizeof(指针步进)

1、sizeof 是运算符，等价于&运算符。
2、sizeof 是在编译阶段展开运算的，在程序运行期间相当于常数。
3、sizeof 实现的原理是指针的步进。

#define 	mysizeof(L_Value)       ((char*)(&L_Value + 1) - (char*)(&L_Value))

同理，可以很方便的得到数组长度（注意不是元素个数)：

1、buff 是数组首元素的地址，步进单位为单个元素长度。
2、&buff 是数组地址，步进单位为整个数组长度。
3、地址指针是void *的，强制转换后进行计算。注意(char *)和(int *)结果不同。
4、64位系统下，int型占用4个字节，int *进行加减运算时，步进单位是4字节，所以计算结果是2。

{
	unsigned char buff[] = {1,2,3,4,5,6,7,8};
	int buff_len = 0;
	buff_len = (char *)(&buff+1) - (char *)(&buff);				//buff_len = 8;
	buff_len = (char *)(buff+1) - (char *)(buff);				//buff_len = 1;
    buff_len = (int *)(&buff+1) - (int *)(&buff);				//buff_len = 2;
}

上面得到的是数组的长度，那么如何得到数组的元素个数呢？

{
	long buff[] = {1,2,3,4,5,6};
	int  len = 0;
	len = sizeof(buff)/sizeof(buff[0]);		//len = 6;
}

八、指针常量和常量指针

①、常量指针

定义：指向常量的指针。
1、本质上是指针，指向的值是常量，故不能通过这个指针修改变量的值。
2、但指针并非常量，指针可以指向其他的地址。
形式：

const int *p;
int const *p;

②、指针常量(常指针)

定义：指针类型的常量。
1、本质上是常量，这个常量的内容是指针，即一个地址。
2、指针是常量，但对应地址里面的值并非常量，所以指针指向的值可以改变。
形式：

int* const p;

两种如何理解？

看名称后两个字：

常量指针：本质是指针。因为它还可以指向其他任意一个地址。const只不过限定了该地址的值不
能被改变。
指针常量：本质是常量。指针是这个常量的类型修饰符。

看const修饰符的位置：

常量指针：const int *p和int const *p，const实质上修饰的是*p。即值是常量。
指针常量：int const* p，const实质上修饰的是p，即地址是常量。

指向常量的常指针

const int* const p;

即p指向的值是一个常量，且p本身是一个指针常量，即p不能再指向其他地址。