C语言基础知识（3）

1. 命令行传参（main函数的标准写法）

命令行传参：在程序运行的时候，给程序传递参数

shell脚本命令行传递参数，系统预设变量
bash test.sh aa bb cc
$0—>test.sh
$1—>aa
$2—>bb
$3—>cc
$#—>3
$*—>aa bb cc

main 函数的标准
arg —>argument–参数 c—>count 数量 v—> value 值
argc：参数个数
argv：参数值
const —> 关键字常量，表示不能更改
char *argv[]—>字符指针数组，元素类型char *
int main(int argc, const char *argv[])
{xxxxxxx}
执行：./a.out aa bb cc

#include <stdio.h>

int main(int argc, const char *argv[])
{
    printf("参数个数是：%d\n",argc);
    int i;
    for(i = 0; i < argc; i++)
    {
        //argv[0] --->a.out
        printf("argv[%d]------>%s\n",i,argv[i]);
    }
    return 0;
}

2. 递归函数

一个函数直接或间接的调用自己就是递归函数

可以参考该链接：https://bbs.huaweicloud.com/blogs/290255

2.1 递归的两种方式

1. 直接调用自己

#include <stdio.h>

void fun()
{
    int a[10000];//加速程序，栈空间不足
    printf("hello word!\n");
    fun();
    //这行不会别打印出来，因为一直在调用自己，每次调研fun函数都没有结束，不会走到这行
    printf("11111111111\n");
}

int main(int argc, const char *argv[])
{
    fun();
    return 0;
}

2. 间接调用

#include <stdio.h>

void fun1();
void fun()
{
    int a[10000];//加速程序，栈空间不足
    printf("hello word!\n");
    fun1();
    //这行不会别打印出来，因为一直在调用自己，每次调研fun函数都没有结束，不会走到这行
    printf("11111111111\n");
}
void fun1()
{
    fun();
}
int main(int argc, const char *argv[])
{
    fun();
    return 0;
}

2.2 递归函数注意事项

递归函数占空间较大，容易造成死循环，一定要有递归的结果条件
让一个函数结束需要加上return语句

#include <stdio.h>

int getSum(int n)
{
    if(n==1)
    {
        return 1;
    }
    int result = getSum(n - 1) + n;
    printf("111111\n");
    return result;
}
/*
    进栈顺序：
    main函数
    getSum(4)   result = getSum(4 -1 ) +4    // n= 4
    getSum(3)   result = getSum(3-1 ) + 3   // n = 3
    getSum(2)   result = getSum(2 -1 ) +2   //n = 2
    getSum(1)   return 1                                //n = 1
    出栈顺序：
    return 1 
    return 1 + 2 = 3    //打印一次
    return  3 + 3 =6    //打印一次
    return  6 + 4 =10  //最终， //打印一次
    sum = 10
   
*/

int main(int argc, const char *argv[])
{
   int sum = getSum(4);
   printf("sum is %d\n",sum);
    return 0;
}

3. const关键字

const 关键字：常量化意思，不可改，会造成语法错误

1. const int a 【修饰变量，变量值不可修改】

#include <stdio.h>

int main(int argc,const char *argv[])
{
	const int a = 10; //变量a，经过const修饰后，变为常量，不可改
	a = 200;
	printf("a is %d\n",a);
	return 0;
}

编译不通过

2. const int *p = &a;（int const p = &a）【const修饰的p，p指向的内存空间的值不能改】

#include <stdio.h>

int main(int argc,const char *argv[])
{
	int a = 10; 
	const int *p = &a; //const修饰的*p p指向的内存空间的值不能改
    //int const *p = &a; 写法等价
    *p = 200;
	printf("a is %d\n",a);
	return 0;
}

3. int * const p; 【const修饰p，p的指向不能修改】

#include <stdio.h>

int main(int argc,const char *argv[])
{
	int a = 10; 
    int b = 20;
	int * const p = &a; //const修饰的p, p的指向不能修改
    *p = 200; //正确
    p = &b; // 编译报错
    *p = 400;
	printf("a is %d\n",a);
	return 0;
}

4. int const * const p; ( const int* const p = &a; )【const修饰*和p，意味着值和指向都不能修改】

#include <stdio.h>

int main(int argc,const char *argv[])
{
	int a = 10; 
    int b = 20;
	int const  * const p = &a; //const修饰的p, p的指向不能修改
    // const int* const p = &a;
    *p = 200;  //编译报错
    p = &b; //编译报错
    *p = 400; //编译报错
	printf("a is %d\n",a);
	return 0;
}

5. const int * 等价于 int const * ，一般都是用第一个这样写

4. static 关键字

1. static 修饰一个局部变量的时候，此时这个局部变量被称为静态变量
   作用域不变，生命周期延长至整个程序结束
   静态局部变量多次调用只初始化一次，未初始化值是0，存放在全局区
2. static 修饰一个全局变量和函数时，只能在本文件中使用，不能被其他文件调用
   

修饰局部变量的例子

#include <stdio.h>

void fun()
{
    int num = 1;
    num ++;
    printf("fun num is %d \n",num);
}

int main(int argc,const char *argv[])
{
	fun();
    fun();
    fun();
	return 0;
}

#include <stdio.h>

void fun()
{
    static int num = 1; //num就是静态变量
    num ++;
    printf("fun num is %d \n",num);
}

int main(int argc,const char *argv[])
{
	fun();
    fun();
    fun();
	return 0;
}

修饰全局变量的例子

#include <stdio.h>

int max = 100;
void showMax()
{
    printf("showMax : max is %d\n",max);
}

#include <stdio.h>
//要想引用a.c 里的max和showMax 
extern int max; //引用外部的
extern void showMax();


int main(int argc,const char *argv[])
{
	printf("main : max is %d\n",max);
    showMax();
	return 0;
}

#include <stdio.h>

static int max = 100;
static void showMax()
{
    printf("showMax : max is %d\n",max);
}

#include <stdio.h>
//要想引用a.c 里的max和showMax 
extern int max; //引用外部的
extern void showMax();


int main(int argc,const char *argv[])
{
	printf("main : max is %d\n",max);
    showMax();
	return 0;
}

5. extern 关键字

作用：外部引用声明
a.c 想要b.c 里的全局变量和函数（必须在同一个文件夹里）
extern void fun(); //调用其他文件的函数
extern int x; //调用其他文件的全局变量

6. typedef 关键字

typedef ----> type 类型 define定义
作用：类型重定义 ，给数据类型重新起个名字

类型重定义一般使用在类型名比较长的情况下

6.1 typedef 与结构体

1. 第一种是基本用法：先定义结构体，再进行类型重定义

#include <stdio.h>
//先定义了结构体
struct student
{
	char name[20];
	int age;
}
//后重新类型定义
typedef struct student stu_t;  //将struct student 重新命名为stu_t,一般重命名的习惯用法是xx_t
int main(int argc, const char *argv[])
{
	struct student s1 = {"asan",19};
	stu_t s2 = {"lili",20};
	printf("name: %s,age: %d\n",s1.name,s1.age);
	printf("name: %s,age: %d\n",s2.name,s2.age);
	return 0;
}

2. 第二种是常用用法：在定义结构体的同时，进行类型重定义

#include <stdio.h>
//在定义结构体的同时，进行类型重定义
typedef struct student
{
	char name[20];
	int age;
}stu_t;

int main(int argc, const char *argv[])
{
	struct student s1 = {"asan",19};
	stu_t s2 = {"lili",20};
	printf("name: %s,age: %d\n",s1.name,s1.age);
	printf("name: %s,age: %d\n",s2.name,s2.age);
	return 0;
}

3. 第三种用的是匿名结构体重定义

#include <stdio.h>
//匿名结构体重定义
typedef struct 
{
	char name[20];
	int age;
}stu_t;

int main(int argc, const char *argv[])
{
	//因为是匿名结构体，只能直接用小名
	stu_t s2 = {"lili",20};
	printf("name: %s,age: %d\n",s2.name,s2.age);
	return 0;
}

7. 头文件

头文件是扩展名为 .h 的文件，包含了 C 函数声明和宏定义，被多个源文件中引用共享。有两种类型的头文件：程序员编写的头文件和编译器自带的头文件。

以下是头文件可能包含的内容：

1. 函数声明：头文件中通常包含了函数的原型声明。这些声明描述了函数的名称、参数类型和返回类型，允许在其他源文件中调用这些函数。
2. 全局变量声明：头文件中可以包含全局变量的声明。这些声明用于告诉编译器某个全局变量在其他文件中定义，从而可以在多个源文件中共享该变量。
3. 宏定义：头文件中可以包含宏定义，如预处理指令 #define 定义的常量、宏函数和条件编译指令。
4. 类型定义：头文件中可以包含自定义类型的定义，如结构体、枚举和类型别名。
5. 其他预处理指令：头文件中还可以包含其他预处理指令，如条件编译指令 #ifdef、#ifndef、#endif，用于根据条件选择性地包含不同的代码块。

语法格式：

1. 程序员编写的头文件：#include “a.h”
2. 编译器自带的头文件：#include <stdio.h>

7.1 避免头文件重复包含

可以使用宏定义来进行条件编译

a.h

#ifndef _A_H
#define _A_H
int max = 200; //原则上，全局变量，不要放在.h文件中
#endif

b.h

#ifndef _B_H
#define _B_H
#include "a.h"
#endif

test.c

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

8. 枚举

1. 数据类型

基本数据类型： char int short long float double 指针
构造数据类型：数组 结构体 共用体
空类型：void
枚举类型： enum—>enumerate 的缩写，也就是列举、排列说明的意思。

2. 枚举类型的定义

它用于声明一组命名的常数，当一个变量有几种可能的取值时，可以将它定义为枚举类型。
定义枚举类型： enum 枚举类型 {枚举值列表};
枚举就是整型

3. 枚举注意点

1. 枚举类型中，声明的第一个枚举成员默认值为0
2. 以后每个没有被赋值的枚举成员值将是前一个枚举成员的值加1得到的
3. 定义枚举类型时，可以为枚举成员显示赋值，允许多个枚举成员有相同的值
4. 没有显示赋值的枚举成员的值，总是前一个枚举成员的值+1

9. 共用体

共用体是多个成员变量，共用同一块内存空间，所以的成员变量，起始地址一样
任意时刻，只能保证一个成员变量存储的数据是有效的
作用：一般应用在单片机方面

1. 共用体定义

1. 共用体（Union），它的定义格式为：

union 共用体名{
    成员列表
};

共用体有时也被称为联合或者联合体，这也是 Union 这个单词的本意。

2. 结构体和共用体的区别在于：结构体的各个成员会占用不同的内存，互相之间没有影响；而共用体的所有成员占用同一段内存，修改一个成员会影响其余所有成员。

结构体占用的内存大于等于所有成员占用的内存的总和（成员之间可能会存在缝隙），共用体占用的内存等于最长的成员占用的内存。共用体使用了内存覆盖技术，同一时刻只能保存一个成员的值，如果对新的成员赋值，就会把原来成员的值覆盖掉。

作用（单片机方面）

共用体在一般的编程中应用较少，在单片机中应用较多。

#include <stdio.h>

union data
{
	int a;
	double b;
	char c;
};

int main(int argc, const char *argv[])
{
	//定义一个共用体变量,名字叫s
	union data s;
	s.a = 10;
	printf("s.a is %d\n",s.a);
	s.b = 888.88;
	printf("s.b is %lf\n",s.b);
	printf("s.a is %d\n",s.a);//s.a受到 s.b赋值的影响,因为共用体公用的是同一块内存,起始地址一样.相互干扰
	return 0;
}

共用体同一时刻只能保持一个有效