初始C语言4

目录

11.常见关键字（续） 

11.1关键字 typedef

11.2 关键字static(静态的)

11.2.1static修饰局部变量

11.2.2static修饰全局变量

11.2.3 static修饰函数

12. #define 定义常量和宏

13. 指针

     13.1 内存

13.2 指针变量的大小

14.结构体

---

11.常见关键字（续） 

11.1关键字 typedef

        typedef 顾名思义是类型定义，这里应该理解为类型重命名。

//将unsigned int 重命名为uint_32, 所以uint_32也是一个类型名
typedef unsigned int uint_32;
int main()
{
    //观察num1和num2,这两个变量的类型是一样的
    unsigned int num1 = 0;
    uint_32 num2 = 0;
    return 0;
}

11.2 关键字static(静态的)

在C语言中static有三种用法

static是用来修饰变量和函数的

        1. 修饰局部变量-称为静态局部变量

        2. 修饰全局变量-称为静态全局变量

        3. 修饰函数-称为静态函数

11.2.1static修饰局部变量

        请对比一下俩个代码的结果

        

void test()
{
    int i = 1;
	i++;
	printf("%d ", i);
}


int main()
{
	int i = 0;
	while (i < 5)
	{
		test();
		i = i + 1;
	}
	return 0;
}

void test()
{
	static int i = 1;
	i++;
	printf("%d ", i);
}


int main()
{
	int i = 0;
	while (i < 5)
	{
		test();
		i = i + 1;
	}
	return 0;
}

        运行结果如下：

对比代码1和代码2的效果理解static修饰局部变量的意义。

在此之前先讲解下内存

在C/C++程序中会把内存分为三个区域 栈区 堆区 静态区

如图所示

所以在static没有修饰int的时候 int是局部变量在栈区

当int 被static修饰了过后 int是静态变量在静态区

这就是为什么俩次运行结果不同的原因

结论:

这时局部变量就是静态的局部变量

一个普通的局部变量进入函数创建，出函数销毁

 但是被static修饰之后，进入函数时已经创建好了，出函数的时候也不销毁，多次调用函数时，共享一个变量

主观的感受：生命周期变长了或者说延长了生命周期，但是作用域不变，只能在局部范围内使用

本质是什么: 普通的局部变量是放在栈区上的，但是被static修饰后，是存放在静态区的，静态区的变量生命周期跟全局变量生命周期一样的

11.2.2static修饰全局变量

//代码1
//add.c
int g_val = 2023;
//test.c

extern  int g_val
int main()
{
    printf("%d\n", g_val);
    return 0;
}
//代码2
//add.c
static int g_val = 2023;
//test.c

extern int g_val
int main()
{
    printf("%d\n", g_val);
    return 0;
}

代码1正常，代码2在编译的时候会出现连接性错误。

因为全局变量g_val被static修饰了

一个全局变量可以在整个工程的其它文件内部能被使用，是因为全局变量具有外部链接属性，当全局变量被static修饰时，这个外部链接属性就变成了内部链接属性（该全局变量只能在自己所在源文件中使用，感觉是作用域变小了）
修饰函数和修饰全局变量一样，改变链接属性

结论：

全局变量是具有外部链接属性的
这种属性决定了全局变量在多个文件可以相互使用

static修饰全局变量的时候，将外部链接属性变成了内部链接属性
g_val只能在当前的.c文件内部使用，不能在其他的.c文件中使用了

给我们的感受:改变了作用域

11.2.3 static修饰函数

//代码1
//add.c

extern int Add(int x, int y)
int Add(int x, int y)
{
    return c+y;
}
//test.c
int main()
{
    printf("%d\n", Add(2, 3));
    return 0;
}
//代码2
//add.c
extern int Add(int x, int y)
static int Add
(int x, int y)
{
    return c+y;
}
//test.c
int main()
{
    printf("%d\n", Add(2, 3));
    return 0;
}

代码1正常，代码2在编译的时候会出现连接性错误

跟修饰全局变量同理

结论：

函数也是具有外部链接属性的
这种属性决定了函数可以跨文件使用的
static修饰函数是吧函数的外部链接属性改变成了内部链接属性
使得函数只能在自己的.c文件中使用

12. #define 定义常量和宏

常量：

1.字面常量

2.const修饰的常变量

3.#define 定义的标识符常量

4.枚举常量

//define定义标识符常量
#define MAX 1000
#define ch 'x'
//define定义宏
#define ADD(x, y) ((x)+(y))
#include <stdio.h>
int main()
{
    int sum = ADD(2, 3);
    printf("sum = %d\n", sum);
    
    sum = 10*ADD(2, 3);
    printf("sum = %d\n", sum);
    
    return 0;
}

宏可以有参数

13. 指针

     13.1 内存

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的 。

所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。

为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地 址。

在C语言中把地址也叫指针    所以 编号=地址=指针

未来，只要指定了一个地址，通过地址就能找到对应的内存单元

int main()
{
	int a = 10;
	int * pa =&a;//0x0012ff48  -内存的变化==地址==指针，pa叫指针变量
	//*是在说明pa是指针变量
	//int是在说明pa指向的是int类型的指针变量
	*pa = 20;//*解引用操作符 - 通过地址找到地址所指向的对象。*pa就等价于a
	printf("%d", a);
	return 0;
}

总结：
1.内存会被划分以字节为单位的一个的内存单元
2.每个内存单元都有编号，编号 = 地址 = 指针
3.C语言中创建的变量，其实是向内存申请一块空间，比如：int a = 10,就是向内存申请4个字节空间，每个字节都有地址
4.&a的时候，拿出来的是4个字节中地址较小的那个字节的地址(编号)
5.这个地址要存储起来，给一个变量，这个变量是用来存放地址（指针）所以叫做指针变量：int *pa = &a;
6.pa中存放的地址，要通过pa中的地址找到a，怎么写？ *pa--> 通过pa中的地址找到a *pa = 20；本质是修改a

13.2 指针变量的大小

int main()
{
	int* pc;
	char* pi;
	short* pd;
	double* zd;
	printf("%d\n",sizeof(pc));
	printf("%d\n", sizeof(pi));
	printf("%d\n", sizeof(pd));
	printf("%d\n", sizeof(zd));
	return 0;
}

 运行结果如下

不管什么类型的指针变量，大小都是4个字节

但是

在32位平台下地址是32个bit位（即4个字节）

在64位平台下地址是64个bit位（即8个字节）

如下

在64为环境下就是8个字节

指针变量是用来存放地址的

指针变量的大小，就取决于存放一个地址需要的多大的空间

32位：一个地址的大小是32bit位，需要4个字节

           所以一个指针变量大小是64个字节

64位环境下：

64跟地址线-64个bit位=8个字节

指针变量的大小是8个字节

结论：指针大小在32位平台是4个字节，64位平台是8个字节。

14.结构体

结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型。

比如描述学生，学生包含： 名字+年龄+性别+学号 这几项信息。

这里只能使用结构体来描述了。

列如

struct stu
{
	char name[20];
	int age;
	float score;
};

int main()
{
	int num;

	struct stu s1 = { "张三",20,88.0f };
	struct stu s2 = { "李四",20,65.5f };
	struct stu s3 = { "王五",20,99.8f };

	struct stu* ps1 = &s1;
	printf("%s %d %f\n", ps1->name, ps1->age, ps1->score);
	printf("%s %d %f\n", s1.name, s1.age, s1.score);
	printf("%s %d %f\n", s2.name, s2.age, s2.score);
	printf("%s %d %f\n", s3.name, s3.age, s3.score);

	

	return 0;

运行结果如下

打印结构体有俩种方法 

1.结构体变量.结构体成员
2.结构体指针->结构体成员

至于为什么99.8后面有个3 

因为浮点数在内存中无法精确保存。