字符串
字符串的定义方法
注意：char *data3 = “hello3”;//字符串常量，不允许被修改
#include <stdio.h>
int main()
{
char data[] = {'h','e','l','l','o'};//字符数组
char data2[] = "hello2";//可修改
char *data3 = "hello3";//字符串常量，不允许被修改
for(int i=0;i<5;i++){
printf("%c",data[i]);
}
printf("\n%s",data2);
putchar('\n');
puts(data3);
return 0;
}
================================================================.
野指针：没有明确的内存指向，编译代码时会产生段错误
=========================================================================================================
关于字符串的结束标志’\0’
使用sizeof会计算到‘\0’这个字符
使用strlen则直接计算出字符串的真实长度，但注意要加头文件#iclude <string.h>
#include <stdio.h>
#include <string.h>
int main()
{
char data[] = {'h','e','l','l','o'};//字符数组
char data2[] = "hello";//这里会算出6，因为字符串的结束标志‘\0’
printf("data:%d\n",sizeof(data)/sizeof(data[0]));
printf("data2:%d\n",sizeof(data2)/sizeof(data2[0]));
printf("data2:%d\n",strlen(data2));//使用strlen计算则会计算出字符串的真实长度为5
return 0;
}
=========================================================================================================
- sizeof和strlen的区别： sizeof计算的是分配空间的实际字节数 strlen计算的是分配空间的实际字节数
- sizeof是运算符，可以以类型、函数、做参数 strlen是函数，只能以char*(字符串)做参数。而且，要想得到的结果正确必须包含 ‘\0’
3.sizeof是在编译的时候就将结果计算出来了是类型所占空间的字节数，所以以数组名做参数时计算的是整个数组的大小。而strlen是在运行的时候才开始计算结果
#include <stdio.h>
#include <string.h>
int main()
{
char data[128] = "hello";
char *data2 = "hello";
printf("data sizeof:%d\n",sizeof(data));//这里算出128，因为data数组开辟的就是128个字符元素，但只用到了6个（包括'\0'）
printf("data strlen:%d\n",strlen(data));//这里算出5，因为字符串实际长度为5
printf("data2 sizeof:%d\n",sizeof(data2));//8,因为data是指针，即地址，八位字节表示一个地址
printf("data2 strlen:%d\n",strlen(data2));//5，因为字符串实际长度为5
return 0;
}
================================================================================================================================================================================
malloc时动态内存分配函数，用于申请一块连续的指定大小的内存块区域以void*类型返回分配的内存区域地址
#include <stdlib.h>
void *malloc(unsigned int num_bytes);
void*可以强转为其他类型
free函数：防止内存泄漏，防止悬挂指针
释放malloc(或calloc、realloc)函数给指针变量分配的内存空间
注意：使用后该指针变量一定要重新指向NULL，防止悬空指针（失效指针）出现，有效规避错误操作。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char *p;
p = (char *)malloc(12);
strcpy(p,"helloworld");
puts(p);
free(p);
p = NULL;
return 0;
}
内存扩容
realloc函数使我们动态内存管理更加灵活。
有时会发现过去申请的空间太小了，有时候我又会觉得申请的空间太大了，那为了合理的内存，我们呢一定会对内存进行灵活的调整，realloc就可以做到对内存大小的调整。
函数原型：void* realloc(void*ptr,size_t size)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char *p;
p = (char *)malloc(12);
printf("扩容前：%x\n",p);
int len = strlen("helloworld00000000000000000000000");
int newlen = len-12+1;
realloc(p,newlen);
printf("扩容后：%x\n",p);
strcpy(p,"helloworld00000000000000000000000");
puts(p);
free(p);
p = NULL;//防止悬挂指针，属于野指针的一种
return 0;
}
=====================================================================================================================================================================
memset是一个初始化函数，作用是将某一块内存中的全部设置为指定的值
void *memset(void *s, int c, size_t n);
例如将上述的p进行清空
memset(p,‘\0’,12);
=====================================================================================================================================================================
字符串操作常用的API
输出字符串：puts(); printf(“%s”,p);
int main()
{
char *p = "hello";
puts(p);
printf("%s\n",p);
return 0;
}
=====================================================================================================================================================================
获取字符串：
scanf(“%s”,p);gets(); 原型:char *gets(char *str);
因为本函数可以无限读取，容易发生溢出，如果溢出，多出来的字符将被写入堆栈中，这就覆盖了堆栈原本的内容，破花一个多种多个不相关变量的值
========================================================================================================================================================================
仿写strcpy函数
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *myStrcpy(char *des,char *src)
{
if(src == NULL || des == NULL){
return NULL;
}
char *bak = des;
while(*src != '\0'){
*des++ = *src++;
}
des = '\0';//加上字符串结束标志
return bak;
}
int main()
{
char * src = "hello world\n";
char *des;
int len;
len = strlen(src);
des = (char *)malloc(len+1);
myStrcpy(des,src);
puts(des);
return 0;
}
加上自定义需呀拷贝的长度，让它只拷贝hello
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *myStrcpy(char *des,char *src,int count)
{
if(src == NULL || des == NULL){
return NULL;
}
char *bak = des;//保存des的起始地址
while(*src != '\0' && count>0){
*des++ = *src++;
count--;
}
des = '\0';//加上字符串结束标志
return bak;//返回des的起始地址
}
int main()
{
char * src = "hello world\n";
char *des;
int len;
len = strlen(src);
des = (char *)malloc(len+1);
myStrcpy(des,src,5);
puts(des);//从起始地址开始输出des保存的内容
return 0;
}
========================================================================================================================================================================
assert()断言函数，用于在调试过程中捕捉程序错误
所在头文件：<assert.h>
函数原型：void assert (int expression);
参数：expression即要检测的表达式
返回值：无返回值
======================================================
“断言”在语文中的意思是“断定”、“十分肯定地说”，在编程中是指对某种假设条件进行检测，如果条件成立就不进行任何操作，如果条件不成立就捕捉到这种错误，并打印出错误信息，终止程序执行。
======================================================
assert() 会对表达式expression进行检测：
如果expression的结果为 0（条件不成立），那么断言失败，表明程序出错，assert() 会向标准输出设备（一般是显示器）打印一条错误信息，并调用 abort() 函数终止程序的执行。
如果expression的结果为非 0（条件成立），那么断言成功，表明程序正确，assert() 不进行任何操作。
=====================================================================================================================================================================
拼接字符串：strcat
常用的字符串API参考文章：http://t.csdn.cn/1cDyy
char * strcat ( char * destination, const char * source );
================================================================================================================
实现mystrcat
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
char* mystrcat(char *des,char *src)
{
assert(des != NULL && src != NULL);
char *bak = des;
while(*des != '\0'){
des++;
}
while(*src != '\0'){
*des++ = *src++;
}
*des = '\0';
return bak;
}
char* mystrcat2(char *des,char *src)
{
assert(des != NULL && src != NULL);
char *bak = des;
strcpy(des+strlen(des),src);
return bak;
}
int main()
{
char *des1 = "hello ";//不能对字符指针常量进行修改操作（//*des1 = *src;），会产生段错误
char des[24] = "hello ";
char *src = "world";
char *ret;
ret = mystrcat2(des,src);
puts(ret);
return 0;
}
====================================================================================================================================================
strcat的错误使用，其实从原型的参数中也可以看出第一个参数不能为常量
int main()
{
char *des1 = "hello ";//不能对字符指针常量进行修改操作（//*des1 = *src;），会产生段错误
char *src = "world";
char *ret;
ret = strcat(des1,src);//两个都是字符指针常量，由于无法对des1进行修改，导致程序出现段错误
puts(ret);
return 0;
}
===========================================================================================================================
char *strncat(char *dest, const char *src, size_t n) 把 src 所指向的字符串追加到
dest 所指向的字符串的结尾，直到 n 字符长度为止
char *strncat(char *dest, const char *src, size_t n)
#include <stdio.h>
#include <string.h>
int main(void) {
char str1[6] = "hello";
char str2[6] = "world";
strncat(str1,str2,2);
printf("str1 = %s\n",str1);
printf("str2 = %s\n",str2);
int len = strlen(str1);
printf("len的长度:%d\n",len);
return 0;
}
===============================================================================================================
字符比较
写法：int strcmp(const char s1,const chars2)
当s1 < s2时，返回为负数； 当s1 == s2时，返回值= 0； 当s1 > s2时，返回为正数
下面这个多了一个num参数，就是设置比较多少位
函数原型：int strncmp(const char* str1, const char* str2, size_t num) 头 文
件：#include <string.h> 返 回 值：（与strncmp相同）str1 = str2 则返回0，
str1 > str2 则返回大于0的值，
str1 < str2 则返回小于0的值
================================================================================================================================
结构体
定义一个结构体：存放多种不同类型的变量
点运算符是用来访问结构体里面的成员的
#include <stdio.h>
struct Student{
int num;
char *name;
}stu1,stu2;
int main()
{
//Student stu1;
stu1.num = 01;//使用点运算符
stu1.name = "KK";
printf("%d %s\n",stu1.num,stu1.name);
stu2.num = 02;
stu2.name = "LL";
printf("%d %s\n",stu2.num,stu2.name);
return 0;
}
或者下面这样定义
#include <stdio.h>
struct Student{
int num;
char *name;
};
int main()
{
struct Student stu1;
struct Student stu2;
//定义的时候直接初始化
struct Student stu3 = {03,"PP"};
stu1.num = 01;//使用点运算符
stu1.name = "KK";
printf("%d %s\n",stu1.num,stu1.name);
stu2.num = 02;
stu2.name = "LL";
printf("%d %s\n",stu2.num,stu2.name);
return 0;
}
注意：如果定义的时char name[24]，如果一开始没有赋值，则后面使用的时候，不能直接name =“kk”，而是使用strcpy(name,“kk”)
====================================================================================================================
结构体数组
定义结构体数组及遍历
#include <stdio.h>
struct Student{
int num;
char name[24];
char sex;
};
int main()
{
struct Student arr[3] = {{01,"kk",'b'},{02,"kk",'b'},{03,"ww",'b'}};
int len = sizeof(arr)/sizeof(arr[0]);
for(int i=0;i<len;i++){
printf("arr[%d]:%d %s %c\n",i,arr[i].num,arr[i].name,arr[i].sex);
}
return 0;
}
===========================================================================================================================================================================
结构体：选民系统
#include <stdio.h>
#include <string.h>
struct Voter{
char name[24];
int tickets;
};
int main()
{
struct Voter xm[3];
struct Voter Max;
int i,j = 0;
int feipiao = 0;
int mark = 0;
char tmpName[24];
int len = sizeof(xm)/sizeof(xm[0]);
//初始化选民
for(i=0;i<len;i++){
xm[i].tickets = 0;
printf("输入选民%d:\n",i+1);
scanf("%s",xm[i].name);
}
//唱票环节
for(i=0;i<5;i++){//假如5个人投票
mark = 0;
memset(tmpName,'\0',sizeof(tmpName));
printf("请输入你投给谁？");
scanf("%s",tmpName);
for(j=0;j<len;j++){
if(strcmp(tmpName,xm[j].name) == 0){
xm[j].tickets++;
mark = 1;
}
}
if(mark == 0){
printf("无此候选人\n");
feipiao++;
}
}
//公布结果
for(i=0;i<len;i++){
printf("姓名:%s 票数:%d\n",xm[i].name,xm[i].tickets);
}
printf("废票:%d\n",feipiao);
Max = xm[0];
for(i=1;i<len;i++){
if(Max.tickets < xm[i].tickets){
Max = xm[i];
}
}
printf("最终获选人:%s 票数:%d\n",Max.name,Max.tickets);
return 0;
}
引入结构体指针变量
结构体指针的定义和理解：用->运算符访问结构体指针的成员
注意：指针++造成地址的偏移，多次遍历记得要把指针指回数组头，不然会越界访问
#include <stdio.h>
struct Test{
int a;
char b;
};
int main()
{
struct Test t1 = {10,'c'};
struct Test *ps;//定义结构体指针
ps = &t1;//指向t1这个结构体
printf("%d %c\n",ps->a,ps->b);
ps->a = 20;
ps->b = 'd';
printf("%d %c",ps->a,ps->b);
return 0;
}
上面练习改用结构体指针实现选票系统
#include <stdio.h>
#include <string.h>
struct Voter{
char name[24];
int tickets;
};
int main()
{
struct Voter xm[3];
struct Voter *Max;
struct Voter *p;
p = xm;
int i,j = 0;
int feipiao = 0;
int mark = 0;
char tmpName[24];
int len = sizeof(xm)/sizeof(xm[0]);
//初始化选民
for(i=0;i<len;i++){
p->tickets = 0;
printf("输入选民%d:\n",i+1);
scanf("%s",p->name);
p++;
}
//唱票环节
for(i=0;i<5;i++){//假如5个人投票
mark = 0;
memset(tmpName,'\0',sizeof(tmpName));
p = xm;
printf("请输入你投给谁？");
scanf("%s",tmpName);
for(j=0;j<len;j++){
if(strcmp(tmpName,p->name) == 0){
p->tickets++;
mark = 1;
}
p++;
}
if(mark == 0){
printf("无此候选人\n");
feipiao++;
}
}
//公布结果
p = xm;
for(i=0;i<len;i++){
printf("姓名:%s 票数:%d\n",p->name,p->tickets);
p++;
}
printf("废票:%d\n",feipiao);
p = xm;
Max = p;
p++;//先偏移一次，从第二和Max比
for(i=1;i<len;i++){
if(Max->tickets < p->tickets){
Max = p;
}
p++;
}
printf("最终获选人:%s 票数:%d\n",Max->name,Max->tickets);
return 0;
}
===========================================================================================================================================================================
上面例子用函数封装的方式再次重写
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct Voter{
char name[24];
int tickets;
};
struct Voter* Initxm(struct Voter *p,int *total)
{
if(p == NULL){
printf("请输入选民个数:\n");
scanf("%d",total);
p = (struct Voter *)malloc((*total)*sizeof(struct Voter));
for(int i=0;i<(*total);i++){
printf("输入选民%d:\n",i+1);
scanf("%s",p->name);
p++;
}
}
return p-(*total);
}
void printfVoter(struct Voter *p,int total)
{
for(int i=0;i<total;i++){
printf("选民%d:%s\n",i+1,p->name);
p++;
}
}
int doVot(struct Voter *p,int total)
{
struct Voter *temp = p;
int ticket = 5;//假设有5票
int mark = 0;
int feipiao = 0;
char tep[24];
for(int i=0;i<ticket;i++){
mark = 0;
memset(tep,'\0',sizeof(tep));
printf("请输入要投的人:\n");
scanf("%s",tep);
p = temp;
for(int j=0;j<total;j++){
if(strcmp(tep,p->name) == 0){
p->tickets++;
mark = 1;
}
p++;
}
if(mark == 0){
printf("查无此人\n");
feipiao++;
}
}
return feipiao;
}
void Result(struct Voter *p,int total)
{
for(int i=0;i<total;i++){
printf("选民%d:%s 票数:%d\n",i+1,p->name,p->tickets);
p++;
}
}
void getMax(struct Voter* p,int total)
{
struct Voter* Max;
Max = p;
p++;
for(int i=0;i<total;i++){
if(Max->tickets < p->tickets){
Max = p;
}
p++;
}
printf("%s以%d票当选\n",Max->name,Max->tickets);
}
int main()
{
struct Voter *xm = NULL;
int total;
int fiepiao;
xm = Initxm(xm,&total);
printfVoter(xm,total);
fiepiao = doVot(xm,total);
Result(xm,total);
getMax(xm,total);
return 0;
}
=========================================================================================================================================================================================
二级指针结构体
上面例子改用二级指针既然个体实现
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct Voter{
char name[24];
int tickets;
};
void Initxm(struct Voter **pxm,int *pt)
{
if(*pxm == NULL){
printf("输入参选人数:\n");
scanf("%d",pt);
*pxm = malloc((*pt)*sizeof(struct Voter));
}
for(int i=0;i<(*pt);i++){
printf("输入参数人%d:",i+1);
scanf("%s",(*pxm)->name);
(*pxm)++;
}
*pxm = *pxm - (*pt);
}
void printfVoter(struct Voter *p,int total)
{
for(int i=0;i<total;i++){
printf("选民%d:%s\n",i+1,p->name);
p++;
}
}
int doVot(struct Voter *p,int total)
{
struct Voter *temp = p;
int ticket = 5;//假设有5票
int mark = 0;
int feipiao = 0;
char tep[24];
for(int i=0;i<ticket;i++){
mark = 0;
memset(tep,'\0',sizeof(tep));
printf("请输入要投的人:\n");
scanf("%s",tep);
p = temp;
for(int j=0;j<total;j++){
if(strcmp(tep,p->name) == 0){
p->tickets++;
mark = 1;
}
p++;
}
if(mark == 0){
printf("查无此人\n");
feipiao++;
}
}
return feipiao;
}
void Result(struct Voter *p,int total)
{
for(int i=0;i<total;i++){
printf("选民%d:%s 票数:%d\n",i+1,p->name,p->tickets);
p++;
}
}
void getMax(struct Voter* p,int total)
{
struct Voter* Max;
Max = p;
p++;
for(int i=0;i<total;i++){
if(Max->tickets < p->tickets){
Max = p;
}
p++;
}
printf("%s以%d票当选\n",Max->name,Max->tickets);
}
int main()
{
struct Voter *xm = NULL;
int total;
int fiepiao;
Initxm(&xm,&total);
printfVoter(xm,total);
fiepiao = doVot(xm,total);
Result(xm,total);
getMax(xm,total);
return 0;
}
====================================================================================================================================================
结构体占的是一片连续的内存空间，大小由其变量类型决定
结构体内存存储空间分配的原则：
编译器按照成员列表顺序一个接一个地给每个成员分配内存。只有当存储成员时需要满足正确的边界对齐要求时，成员之间才可能出现用于填充的额外内存空间。
一，结构体变量的首地址要考虑字节对齐，应该为下一个成员的大小的整数倍，不够就需要填充字节
二，结构体每个成员相对于结构体首地址的偏移量，都是该成员的整数倍。
三，结构体的总大小，为结构体 “最宽基本类型成员” (将嵌套结构体里的基本类型也算上，得出的最宽基本类型) 大小的整数倍。
关于结构体大小文章参考：http://t.csdn.cn/WEi6b
总结理解：就是先考虑字节对齐，再考虑最后的总长度是否为最长成员的整数倍，不是则填充字节补齐
#include <stdio.h>
struct Test{
int a;
char b;
char c; //正常加起来为6字节，最后总长度要为最长成员的整数倍，最后填充2字节，共8字节
};
struct Test2{
char a;
int b;
char c;//字节对齐，char a后面要补充3字节，加起来9字节，最后总长再加3字节，共12字节
};
struct Test3{
double a;
int b;
char c;//加起来为13字节，最后总长度要为最长成员的整数倍，最后填充3字节，共16字节
};
int main()
{
printf("Test:%d\n",sizeof(struct Test));
printf("Test2:%d\n",sizeof(struct Test2));
printf("Test3:%d\n",sizeof(struct Test3));
}
下面这个例子更能体现字节对齐的原则
#include <stdio.h>
struct Test3{
char c;//这里字节对齐填充3字节，总长度为16
int b;
double a;
};
struct Test4{
char c;//这里字节对齐填充7字节，总长度为24字节
double a;
int b;
};
int main()
{
printf("Test3:%d\n",sizeof(struct Test3));
printf("Test4:%d\n",sizeof(struct Test4));
}
===============================================================================================================
联合共用体（union）
结构体和共用体的区别在于：
结构体(struct)中所有变量是“共存”的——优点是“有容乃大”，全面；缺点是struct内存空间的分配是粗放的，不管用不用，全分配。而联合体(union)中是各变量是“互斥”的——缺点就是不够“包容”；但优点是内存使用更为精细灵活，也节省了内存空间。结构体的各个成员会占用不同的内存，互相之间没有影响；而共用体的所有成员占用同一段内存，修改一个成员会影响其余所有成员。
结构体占用的内存大于等于所有成员占用的内存的总和（成员之间可能会存在缝隙），共用体占用的内存等于最长的成员占用的内存。共用体使用了内存覆盖技术，同一时刻只能保存一个成员的值，如果对新的成员赋值，就会把原来成员的值覆盖掉。
#include <stdio.h>
struct Test3{
char c;
int b;
double a;
};
union Test4{
char c;
int b;
double a;
};
int main()
{
struct Test3 t1;
union Test4 t2;
printf("Test3:%d\n",sizeof(t1));
printf("union4:%d\n",sizeof(t2));
printf("struct c IP:%p\n",&t1.c);
printf("struct b IP:%p\n",&t1.b);
printf("struct a IP:%p\n",&t1.a);
printf("union c IP:%p\n",&t2.c);
printf("union b IP:%p\n",&t2.b);
printf("union a IP:%p\n",&t2.a);
}
============================================
注意：联合体的数据覆盖问题
============================================
===========================================================================================================================================================================
枚举类型（enum）
枚举的定义：
#include <stdio.h>
enum WeekDay {sun,mon,tus,wed,thur,fir,sat};//定义枚举的时候可以进行赋值
enum {sun1,mon1,tus1,wed1,thur1,fir1,sat1}weekDay1;//可以直接忽略枚举类型名，直接定义枚举变量
int main()
{
enum WeekDay day;
weekDay1 = mon;
day = sun;
printf("day:%d\n",day);
printf("weekDay1:%d\n",weekDay1);
}
==========================================================================================================================================================
typedef关键字
作用：给已经有的变量类型起新名字
#include <stdio.h>
typedef char char_1;
//单片机常用
typedef unsigned int u8;
typedef int u16;
struct Test{
int data;
int data2;
};
typedef struct Test T; //结构体的名字用typedef再起一个名字也很常见
//还能下面这样，在stm32里面的会看到这种写法
typedef struct{
int data3;
int data4;
}Test;
int main()
{
u8 a = 10;
char_1 b = 'v';
printf("a:%d b:%c\n",a,b);
T t1;
t1.data = 1;
t1.data2 = 2;
printf("data1:%d data2:%d\n",t1.data,t1.data2);
Test t2;
t2.data3 = 22;
t2.data4 = 33;
printf("data3:%d data4:%d\n",t2.data3,t2.data4);
}
扫一扫
6213
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
