这篇文章涉及到字符串与指针知识点的相关练习。浮点数与字符串互转、字符串拷贝、字符串比较、指针交换变量、指针优先级、数据类型强制转换、内存拷贝函数等。

1. 浮点数转字符串

将字符串转整数、整数转字符串、浮点数转字符串、字符串转浮点数 封装为函数。
浮点数转字符串:

#include <stdio.h>
#include <string.h>  //字符串处理
void float_to_string(char str[],float data);

int main(void)
{
    char buff[50];
    float data=1234.5;
    float_to_string(buff,data);

    printf("data=%f,buff=%s\n",data,buff);
    return 0;
}

/*
函数功能: 浮点数转字符串
*/
void float_to_string(char str[],float data)
{
    int buff[50];
    int int_data1=data; //提取整数部分
    int int_data2=(data-int_data1)*1000000; //提取小数部分
    int i=0,j=0,k=0;

    //转整数部分
    while(int_data1)
    {
        buff[i]=int_data1%10+'0';
        int_data1=int_data1/10;
        i++;
    }

    //倒序
    for(j=0;j<i;j++)
    {
        str[j]=buff[i-j-1];
    }

    str[j]='.'; //添加小数点
    j++;

    i=0;
    //转小数部分
    while(int_data2)
    {
        buff[i]=int_data2%10+'0';
        int_data2=int_data2/10;
        i++;
    }

    //倒序
    for(k=0; k<i; k++)
    {
        str[j+k]=buff[i-k-1];
    }

    str[j+k]='\0'; //添加结尾符号

    //优化后面0
    i=j+k; //总长度
    for(j=i-1; j>=0; j--)
    {
        if(str[j]=='0')str[j]='\0'; //添加结束符
        else break;
    }
}

2. 封装字符串拼接函数

封装字符串拼接函数:
函数功能实现将a和b字符串拼接在一起。
比如: char a[100]=”123”; char b[]=”456”; 调用函数之后: a[]=”123456”

#include <stdio.h>
#include <string.h>  //字符串处理
void my_strcat(char str1[],char str2[]);

int main(void)
{
    char str1[50]="12345";
    char str2[]="67890";
    //strcat(str1,str2); //字符串拼接
    my_strcat(str1,str2); //字符串拼接
    printf("%s\n",str1);
    return 0;
}

/*
函数功能:字符串拼接
*/
void my_strcat(char str1[],char str2[])
{
    int i=0,len=0;
    while(str1[len]!='\0')
    {
        len++; 
    }

    while(str2[i]!='\0')
    {
        str1[len+i]=str2[i];
        i++;
    }
    str1[len+i]='\0'; //结尾补上'\0'
}

3. 封装字符串的拷贝函数

封装字符串的拷贝函数: 将a字符串拷贝到b字符串。
示例:

#include <stdio.h>
#include <string.h>  //字符串处理
void my_strcpy(char str1[],char str2[]);

int main(void)
{
    char str1[50]="12345";
    char str2[]="67890";
    //strcpy(str1,str2); //字符串拷贝
    my_strcpy(str1,str2);
    printf("%s\n",str1);
    return 0;
}

/*
函数功能:字符串拼接
*/
void my_strcpy(char str1[],char str2[])
{
    int i=0,len=0;
    while(str2[i]!='\0')
    {
        str1[i]=str2[i]; //依次赋值
        i++; 
    }
    str1[i]='\0'; //补上结尾符号
}

4. 封装字符串的比较函数

封装字符串的比较函数: 比较a字符串和b字符串是否相等。 通过返回值进行区分。
示例:

#include <stdio.h>
#include <string.h>  //字符串处理
int my_strcmp(char str1[],char str2[]);

int main(void)
{
    char str1[50]="中国";
    char str2[]="中国";
    int a;
    //a=strcmp(str1,str2);
    a=my_strcmp(str1,str2);
    if(a==0)printf("字符串相等!\n");
    else printf("字符串不相等!\n");
    return 0;
}

/*
函数功能:字符串比较
*/
int my_strcmp(char str1[],char str2[])
{
    int i=0;
    //只要有一个数组没结束就继续
    while(str1[i]!='\0'||str2[i]!='\0')
    {
        if(str1[i]!=str2[i])break;
        i++;
    }
    if(str1[i]=='\0' && str2[i]=='\0')return 0; //相等
    else return -1; //不相等
}

5. 指针特性

指针: 是C语言的灵魂。
指针: 可访问计算机的底层----->硬件。
定义指针的语法: <数据类型> <变量名称>;
int
p;
指针的特性:

(1)指针本身没有空间。int *p; //定义一个指针变量
(2)指针本身就是地址(专门保存地址)。int *p;  p=?  ?必须是地址类型。

int *p; //定义一个指针变量
    int data=123;
    //p=123; //错误赋值方式
    p=&data; //正确的赋值方式

(3)取出指针指向地址的数据 

    int *p; //定义一个指针变量
    int data=123;
    p=&data; //正确的赋值方式
    printf("%d\n",*p); //取出p指针指向空间的值
    //*p=888; 
(4)指针类型的变量都是占4个字节
#include <stdio.h>
int main()
{
    int *p1; //定义一个整型指针变量
    char *p2;
    float *p3;
    double *p4;
    printf("int=%d\n",sizeof(p1));
    printf("char=%d\n",sizeof(p2));
    printf("float=%d\n",sizeof(p3));
    printf("double=%d\n",sizeof(p4));
    return 0;
}
(5)指针支持自增和自减  ++  --
#include <stdio.h>
int main()
{
    char *p;
    char str[]="1234567890";
    p=str; //将数组地址赋值给指针p

    //指针可以直接使用数组下标(指针可以当数组名使用)
    printf("%c\n",p[0]);//1
    printf("%c\n",p[1]);//2

    //通过指针访问数组的成员
    printf("%c\n",*p); //1
    p++; //指针自增
    printf("%c\n",*p); //2
    p--;
    printf("%c\n",*p); //1
    return 0;
}
(6) 不同类型的指针自增和自减的字节数

//指针类型自增和自减的字节数与本身数据类型有关。

#include <stdio.h>
int main()
{
    int data1[10];
    char data2[10];

    /*1. 给指针赋值合法的空间*/
    int *p1=data1;
    char *p2=data2;

    printf("0x%X\n",p1);
    p1++;
    printf("0x%X\n",p1);

    printf("0x%X\n",p2);
    p2++;
    printf("0x%X\n",p2);
    return 0;
}

6. 通过指针交换两个变量的值

#include <stdio.h>
void func(int *a,int *b);

int main()
{
    int a=100,b=200;
    func(&a,&b);
    printf("a=%d,b=%d\n",a,b); //200,100
    return 0;
}

//通过指针交换两个变量的值
void func(int *a,int *b)
{
    int c;
    c=*a; //取出100
    *a=*b; //取出200赋值给a
    *b=c;
}

7. 指针自增优先级

#include <stdio.h>

int main()
{
    char  buff[]="12345";
    char *p=buff;
    printf("%c\n",*p);  //1
    printf("%c\n",*p++); //1
    printf("%c\n",*p++); //2
    printf("%c\n",*p);   //3
    return 0;
}

8. 计算字符串的长度

#include <stdio.h>
int my_strlen(const char *str);

int main()
{
    printf("%d\n",my_strlen("1234567"));
    return 0;
}

//加const为了防止不小心修改了数据
int my_strlen(const char *str)
{
    //*str='1'; //错误,不能赋值
    char *p=str; //保存地址
    while(*p!='\0')p++;
    return p-str; //得到字符串长度
}

9. 数据类型的强制转换

数据类型的强制转换 (欺骗编译器)
char *p1=(char*)src;
char *p2=(char*)new;

10. 编写一个内存拷贝函数

功能: 可以将任何数据的类型进行相互赋值。
int a,b=100;    float a,b=123.456; ………..
#include <stdio.h>
void my_memcpy(void *new,void *src,int len);
int main()
{
    //int data1=123,data2=456;
    //my_memcpy(&data1,&data2,4);
    //printf("data1=%d\n",data1);

    int data1[100];
    int data2[50]={12,34,5,6,78};
    my_memcpy(data1,data2,sizeof(data2));

    printf("%d\n",data1[0]);
    printf("%d\n",data1[1]);
    return 0;
}

/*
内存拷贝
将src的数据拷贝到new,拷贝len
*/
void my_memcpy(void *new,void *src,int len)
{
    char *p1=(char*)src;
    char *p2=(char*)new;
    int i;
    //for(i=0; i<len; i++)*p2++=*p1++;
    for(i=0; i<len; i++)
    {
        *p2=*p1;
        p1++;
        p2++;
    }
}