嵌入式开发学习--递归函数、string函数族、结构体、结构体数组、结构体指针、结构体大小、共用体、枚举、存储类型

已于 2024-03-20 19:33:24 修改
阅读量1k 收藏 23
点赞数 40
文章标签： 学习 算法 笔记 嵌入式硬件
于 2024-03-19 19:49:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_52407428/article/details/136851640
版权

string函数族

有相同的头文件
strlen

#include <string.h>
size_t strlen(const char *s);

功能：计算字符串实际元素个数
参数：字符串的首地址
返回值：字符串实际元素个数
strcpy

#include <string.h>
char *strcpy(char *dest, const char *src);

功能：字符串的复制
参数：dest目标字符串首地址，src原字符串首地址
返回值：目标字符串首地址

#include<stdio.h>
#include<string.h>
int main(int argc, char const *argv[])
{
    char a[]="hello";
    char b[]="ha";
    strcpy(a,b);
    printf("%s\n",a);
    for(int i=0;i<6;i++)
        printf("%d ",a[i]);
    return 0;
}

会把‘\0’一起复制过去。
strncpy

char *strncpy(char *dest, const char *src, size_t n);

功能：字符串的复制
参数：dest目标字符串首地址，src原字符串首地址，size_t n字符个数
返回值：目标字符串首地址

#include<stdio.h>
#include<string.h>
int main(int argc, char const *argv[])
{
    char a[]="hello";
    char b[]="ha";
    strncpy(a,b,4);
    printf("%s\n",a);
    for(int i=0;i<6;i++)
        printf("%d ",a[i]);
    return 0;
}

strcat

#include <string.h>
char *strcat(char *dest, const char *src);

功能：字符串的拼接
参数：dest目标字符串首地址，src原字符串首地址
返回值：目标字符串首地址

#include<stdio.h>
#include<string.h>
int main(int argc, char const *argv[])
{
    char a[]="hello";
    char b[]="haa";
    strcat(a,b);
    printf("%s\n",a);
    for(int i=0;i<9;i++)
        printf("%d ",a[i]);
    return 0;
}

strcmp

#include <string.h>
int strcmp(const char *s1, const char *s2);

功能：字符串的比较
参数：两个字符串的首地址
返回值：
0 s1==s2
1 s1>s2
-1 s1<s2

#include<stdio.h>
#include<string.h>
int main(int argc, char const *argv[])
{
    char a[33]="hello";
    char b[33]="zaa";
    int i=strcmp(a,b);
    printf("%d\n",i);
    return 0;
}

练习：封装函数实现strcpy的功能

#include<stdio.h>
char copy(char *c,char *d)
{
      while(*d)
      {
          *c=*d;
          c++;
          d++;
      }
      *d='\0';
}
int main(int argc, char const *argv[])
{
    char a[]="sfhdajkhfiuaewhfi";
    char b[]="egnrio;srgtngi";
    copy(a,b);
    puts(a);
    return 0;
}

递归函数

递推阶段：从原问题出发，按递归公式从未知到已知，最终到达递归终止条件(只需了解)。
回归阶段：按递归的终止条件求出结果，逆向逐步带入递归公式，回到原问题求解。

#include<stdio.h>
int fun(int n)
{
     if (n==1)
       {
           return 1;
       }
    return n*fun(n-1);
}
int main(int argc, char const *argv[])
{
    int a=5;
    int i=fun(a);
    printf("%d\n",i);
    return 0;
}

结构体

用户自定义的一种数据类型

格式：

struct 结构体名
{
	成员变量1;
    成员变量2;
    成员变量3;
};
struct ikun
{
    int id;
    int age;
    float height;
    char name[33];
};

成员变量类型：基本数据类型(6种)、指针、数组、结构体类型；不能是函数；

结构体变量

格式：struct 结构体名 结构体变量；
1.定义结构体的同时，直接定义结构体变量
struct 结构体名
{
成员变量1;
成员变量2;
成员变量3;
}结构体变量;

struct ikun
{
    int id;
    int age;
    float height;
    char name[33];
}ik;		//全局变量

2.先定义结构体，再定义结构体变量

struct ikun
{
    int id;
    int age;
    float height;
    char name[33];
};
int main(int argc, char const *argv[])
{
    struct ikun ik;		//局部变量
    return 0;
}

3.缺省结构体名

struct 
{
    int id;
    int age;
    float height;
    char name[33];
}ik;//只能用这一个，不能随意更改

赋值

1.定义结构体同时，直接赋值

#include<stdio.h>
struct ikun
{
    int id;
    int age;
    float height;
    char hobit;
    char name[];
}ik;//或者用的时候再定义
int main(int argc, char const *argv[])
{
    struct ikun ik={1,27,184,5,"kunkun"};
    return 0;
}

2.先定义，再去逐个赋值

#include<stdio.h>
struct ikun
{
    int id;
    int age;
    float height;
    char name[33];
}ik;
int main(int argc, char const *argv[])
{
    ik.id=2;
    ik.height=188.9;
    return 0;
}

3.点等法

#include<stdio.h>
struct ikun
{
    int id;
    int age;
    float height;
    char name[33];
};
int main(int argc, char const *argv[])
{
    struct ikun ik={
        .id=2,
        .age=11,
        .height=156
    };
    return 0;
}

访问

通过：结构体变量名.成员变量名

printf("%d %.1f\n",ik.id,ik.height);
scanf("%d %f %s",&ik.id,&ik.height,ik.name);

重定义typedef

typedef int size_t;
int a;====size_t a;
结构体的数据类型名字太长，重新取个别名；

typedef  struct  ikun
{
}KK;

1.定义的同时重定义
在这里插入图片描述
2.先定义，再重定义
在这里插入图片描述
练习：创建一个名为student的结构体，包含姓名，学号，班级，分数,(数据类型自己定义),从终端输入学生的信息并打印。

#include<stdio.h>
struct ikun
{
    char name[10];
    int id;
    int class;
    float score;
};
int main(int argc, char const *argv[])
{
    struct ikun ik;
    scanf("%s %d %d %1f\n",ik.name,&ik.id,&ik.class,&ik.score);           
    printf("%s %d %d %1f\n",ik.name,ik.id,ik.class,ik.score);
    return 0;
}

结构体数组

结构体类型相同的变量组成的数组
1.定义结构体的同时，定义结构体数组

struct star
{
    int id;
    int age;
    float height;
    char name[33];
}s[3];

2.先定义结构体，再定义结构体数组
在这里插入图片描述

初始化

struct star
{
    int id;
    int a;
    float h;
    char name[33];
}s[2]={
    {1,18,136,"abc"},
    {2,22,123,"qwe"}
};

先定义结构体数组，再对数组的每一个元素进行赋值

#include<stdio.h>
#include<string.h>
struct ikun
{
    char name[10];
    int id;
    int class;
    float score;
};
int main(int argc, char const *argv[])
{
    struct ikun s[3];
    s[0].id=2;
    s[0].class=55;
    s[0].score=44;
    strcpy(s[0].name,"kunkun");
    printf("%s %d %d %f\n",s[0].name,s[0].id,s[0].class,s[0].score);
     return 0;
}

结构体数组的输入输出
在这里插入图片描述
练习:创建一个名为student的结构体数组，包含学号，姓名，分数,(数据类型自己定义),从终端输入学生的信息并打印分数及格的学生信息（输入3人即可）。

#include<stdio.h>
#include<string.h>
struct student
{
    int id;
    int score;
    char name[100];
}st[3]={
    {1,66,"one"},
    {2,55,"two"},
    {3,79,"three"}
};
int main(int argc, char const *argv[])
{
    int i=0;
    for (i=0;i<3;i++)
    {
        if (st[i].score>= 60)
        printf("学号%d 分数%d 姓名%s\n",st[i].id,st[i].score,st[i].name);
    }
    return 0;
}

结构体指针

指向结构体变量的指针
格式：
struct 结构体名 *结构体指针名
在这里插入图片描述
赋值
指针变量名->成员变量名

p->id=5;
p->h=23.3;
strcpy(p->name,"abc");
(*p).id=6;

结构体大小

在这里插入图片描述
在这里插入图片描述
1.在32位系统下，默认的value值为4字节，判断结构体中类型最大成员的字节大小，和默认的value值进行比较，按小的数进行对齐
2.结构体成员进行对齐时遵循地址偏移量是成员类型大小的整数倍，double类型数据存放在4字节的整数倍上
3.结构体成员按顺序进行存储
为什么要字节对齐？
1） 平台原因：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。（提高程序的移植性）
2）性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
3）内存原因：在设计结构体时，通过对齐规则尽可能优化结构体的空间大小至最小空间。

共用体

不同类型的成员变量共用一块地址空间
union 共用体名
{
成员变量;
};
union 共用体名 变量名;

#include<stdio.h>
union abc
{
    int a;
    char b;

};
int main(int argc, char const *argv[])
{
    union abc test;
    test.a=55;
    test.b='a';
    printf("%d %c\n",test.a,test.b);
    printf("%d\n",sizeof(union abc));
    return 0;
}

特点：
1.成员变量共用同一块地址空间
2.成员变量赋值以最后一次为准
3.共用体的大小为成员变量中最大的为准

#include<stdio.h>
union abc
{
    int a;
    char b;

};
int main(int argc, char const *argv[])
{
    union abc test;
    test.a=0x12345678;
    if (test.b==0x78)
    printf("小端\n");
    else
    printf("大端\n");
    return 0;
}

枚举

在实际编程中，有些数据的取值往往是有限的，只能是非常少量的整数，并且最好为每个值都取一个名字，以方便在后续代码中使用，比如一个星期只有七天，一年只有十二个月，一个班每周有六门课程等。
以每周七天为例，我们可以使用#define命令来给每天指定一个名字
格式：

enum 枚举名
{
	value 1,
	value 2,
	value 3,
.......
};

#include<stdio.h>
enum val
{
    a=8,b,c,
};
int main(int argc, char const *argv[])
{
    printf("%d %d %d\n",a,b,c);		//未赋值时，从0开始
    return 0;
}

存储类型

auto static
static修饰的变量会被存放在静态区
在这里插入图片描述
生命周期为整个程序
修饰局部变量，和普通的局部变量作用域没区别，但是生命周期被延长至整个程序
修饰全局变量，限制在本文件使用

#include<stdio.h>
 void fun()
{
    static int a=1;
    a++;
    printf ("%d\n",a);
}
int main(int argc, char const *argv[])
{
     fun();
    fun();
    return 0;
}

被static修饰的变量只初始化一次
extern外部引用，可以引用其他文件中的全局变量和函数。

#include<stdio.h>
int a=5;
void fun()
{
    printf("菜需坤\n");
}

#include<stdio.h>
extern int a;
extern void fun();
int main(int argc, char const *argv[])
{
    fun();
    printf("%d\n",a);
    return 0;
}

补充记录：数组名不可以自增或自减，即++或–，数组名为地址，为指针型常量

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值