C语言基础知识(七)-CSDN博客

本文链接：https://blog.csdn.net/xcinop/article/details/136849318

string函数族

有相同的头文件

strlen

#include <string.h>

size_t strlen(const char *s);

功能：计算字符串实际元素个数

参数：字符串的首地址

返回值：字符串实际元素个数

strcpy

#include <string.h>

char *strcpy(char *dest, const char *src);

功能：字符串的复制

参数：dest目标字符串首地址，src原字符串首地址

返回值：目标字符串首地址

会把'\0'一起复制过去

strncpy

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

功能：字符串的复制

参数：dest目标字符串首地址，src原字符串首地址，size_t n字符个数

返回值：目标字符串首地址

strcat

#include <string.h>

char *strcat(char *dest, const char *src);

功能：字符串的拼接

参数：dest目标字符串首地址，src原字符串首地址

返回值：目标字符串首地址

strcmp

#include <string.h>

int strcmp(const char *s1, const char *s2);

功能：字符串的比较

参数：两个字符串的首地址

返回值：0 s1==s2

1 s1>s2

-1 s1<s2

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

#include <stdio.h>
//用函数实现strcpy

void strcopy(char *a,char *b)
{
    while(*b)
    {
        *a = *b;
        a++;
        b++;
    }
    *a = '\0';
}

int main(int argc, char const *argv[])
{
    char a[33] = "helloinc";
    char b[33] = "world";
    char *p = a;
    char *q = b;
    strcopy(a,b);
    puts(a);

    return 0;
}

递归函数

递推阶段：从原问题出发，按递归公式从未知到已知，最终到达递归终止条件(只需了解)

回归阶段：按递归的终止条件求出结果，逆向逐步带入递归公式，回到原问题求解

结构体

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

格式：

struct 结构体名

{

        成员变量1;

        成员变量2;

        成员变量3;

};

eg:

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.定义结构体同时，直接赋值

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>

typedef struct ikun
{
    int N0;
    int grade;
    int class;
    char name[33];
}STU;

int main(int argc, char const *argv[])
{
    STU s ;
    printf("输入学生的姓名，学号，班级，分数：");
    scanf("%s %d %d %d",s.name,&s.N0,&s.class,&s.grade);
    printf("学生的姓名是%s，学号是%d，班级是%d班，成绩是%d\n",s.name,s.N0,s.class,s.grade);
    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"}

};

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

结构体数组的输入输出

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

#include <stdio.h>
#include <string.h>

typedef struct stu
{
    int id;
    char name[33];
    int score;
}STU;

int main(int argc, char const *argv[])
{
    STU stud[3];
    printf("输入学生信息：");
    for(int i=0;i<3;i++)
    {
        scanf("%d %s %d",&stud[i].id,stud[i].name,&stud[i].score);
    }
    for(int j=0;j<3;j++)
    {
        if(stud[j].score >= 60)
        {
            printf("合格学生：%d %s %d\n",stud[j].id,stud[j].name,stud[j].score);
        }
    }

    return 0;
}

结构体指针

指向结构体变量的指针

格式：

struct 结构体名 *结构体指针名

赋值

指针变量名->成员变量名

p->id=5;

p->h=23.3;

strcpy(p->name,"abc");

(*p).id=6;

结构体大小

在32位系统下，默认的value值为4字节，判断结构体中类型最大成员的字节大小，和默认的value值进行比较，按小的数进行对齐
结构体成员进行对齐时遵循地址偏移量是成员类型大小的整数倍，double类型数据存放在4字节的整数倍上
结构体成员按顺序进行存储

为什么要字节对齐？

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 = 'q';
    printf("%d \n",sizeof(test));

    return 0;
}

特点：

成员变量共用同一块地址空间
成员变量赋值以最后一次为准
共用体的大小为成员变量中最大的为准

共用体测试大小端：

枚举

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

以每周七天为例，我们可以使用#define命令来给每天指定一个名字

格式：

enum 枚举名

{

        value 1,

        value 2,

        value 3,

        .......

};

#include <stdio.h>

enum tnt
{
    a,
    b,
    c,
};

int main(int argc, char const *argv[])
{
    printf("%d %d %d\n",a,b,c);
    return 0;
}

存储类型

auto static

static修饰的变量会被存放在静态区

生命周期为整个程序

修饰局部变量，和普通的局部变量作用域没区别，但是生命周期被延长至整个程序

修饰全局变量，限制在本文件使用

被static修饰的变量只初始化一次

extern外部引用

可以引用其他文件中的全局变量和函数\