C语言_字符串与指针的练习

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

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++;
	}
}