全局变量、sizeof、数组

目录

全局变量

什么是全局变量

static关键字修饰的全局变量   ------>   叫静态全局变量

static关键字修饰的局部变量

sizeof运算

一维数组

二维数组

数组的注意

---

全局变量

什么是全局变量

• 定义在函数外面   ------>   它是可以被全局访问的
• 内存是在程序开始运行的时候就已经分配好了
• 一旦全局变量分配出来后，内存就一直存在，直到程序退出
• 在代码里面你只要能在编译的时候找到这个全局变量，那么都能使用它
• 如果定义的时候没给定初值，初始值一般默认为0

static关键字修饰的全局变量   ------>   叫静态全局变量

• 静态全局变量,静态全局变量只允许在当前的.c文件里面使用   ------>   不能再其他.c文件里使用
• 不带static的全局变量是有办法能在其他的.c文件里面访问的得到    ------>   extern关键字
• 我们每一个.c文件其实可以看作是一个代码模块，如果一个全局变量只在模块内部使用，那么我们一定要把修饰成static, 这样的话，就能够减少维护的成本

static关键字修饰的局部变量

• 它也是个静态全局变量，一开始时候就分配了内存
• 它和定义在外面的静态全局变量的唯一区别是：在函数内部定义的静态全局变量，只能在函数内部使用,其他函数看不到而已
• 函数的调用和返回不会导致这个内存的分配和释放

sizeof运算

• 计算变量所占的内存   ------>   sizeof(变量名)，结果是字节

• 计算类型所占的内存   ------>   sizeof(类型名)，结果是字节

一维数组

• 需要批量定义同等类型的变量

• 类型（每个元素的类型都是一样的）    数组名字[批量的个数]

• 内存大小   ------>   sizeof(数组名)是数组内存的大小 = sizeof(类型名)*个数

• 数组的初始化

    // 读写，访问
    // 我们访问的时候会对数组里面的每个元素进行一个编号,编号是从0开始;
    // 10个数组的元素: 0 ~9, 6个数组的元素 0 ~5;
    // 数组名字[索引的值] // 范围，[0, 数组的个数 - 1];
    c[3] = 9;
    c[4] = 6;
    printf("%d, %d, %d, %d, %d\n", c[0], c[1], c[2], c[3], c[4]);

    // 索引我们上面是常数，我们还可以以变量作为索引;
    int index = 4;
    printf("c[%d] = %d\n", index, c[index]); // ---> 6;

     // 从0开始, < 数组大小 [0, 大小-1]
    for (int i = 0; i < 5; i++) {
        printf("c[%d] = %d\n", i, c[i]);
    }

二维数组

// 二维数组：数据类型 数组名称[行][列];
    int c_a[3][4]; // 定义了一个 3行4列的二维数组;
    int c_b[3][4] = {
    //   0    1   2  3
        {11, 12, 13, 14}, // 第0行
        {21, 22, 23, 24}, // 第1行
        {31, 32, 33, 34}, // 第2行
    };
    // 二维数组也是一段连续的内存;
    // 索引从0开始
    printf("%d\n", c_b[0][0]);
    printf("%d\n", c_b[1][1]);
    printf("%d\n", c_b[2][0]);
    // end

    // 遍历所有的行数:
    for (int i = 0; i < 3; i++) {
        // 遍历列数
        for (int j = 0; j < 4; j++) {
            printf("%d ", c_b[i][j]);
        }
        printf("\n");
    }
    // end
    // 因为内存条是一维，所以二维数组内存上也是1维德，排完一行再排一行

数组的注意

• 数组一旦定义了，大小就再也不能改变了

• 数组一旦定义了，元素的个数就定下来了，那么就只能访问[0，数组大小 - 1]

• 操作时，超出数组的范围，就会越界，程序就会异常

代码练习

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


// 全局变量的特点:
// (1)一旦全局变量分布出来后，这个内存一直存在，只到程序退出;
// (2) 内存是在程序开始运行的时候就已经分配好了;
// (3) 它是可以被全局访问的，这个叫做全部变量;
// (4) 在代码里面你只要能在编译的时候找到这个全局变量，那么都能使用它;
// 如果你没有给定初始值，那么全局变量的初始值一般是0;
int global_value = 100; // 定义一个整形的全局变量

// static 关键字修饰的全局变量;
// 静态全局变量,静态全局变量只允许在当前的.c文件里面使用;
// 不能再其它.c文件里面使用,不带static的全局变量是有办法能在其他的.c文件里面访问的得到;
// static 修饰的全局变量有什么作用呢？
// 我们每一个.c文件其实可以看作是一个代码模块，如果一个全局变量只在模块内部使用;
// 那么我们一定要把修饰成static, 这样的话，就能够减少维护的成本;
static int global_var = 10; 

void test_func() {
	global_value = 30; // 不能使用，编译器在编译test_func的时候，找不到globale_value的定义;
}

void test_static_var() {
	// 他也是个静态全局变量，一开始时候就分配了内存,
	// 它和定义在外面的静态全局变量的唯一区别是:
	// 在函数内部定义的静态全局变量，只能在函数内部使用,其他函数看不到而已
	// 函数的调用和返回不会导致这个内存的分配和释放;
	static int index = 1; 
	index++;
	printf("index %d\n", index);
}

int main(int argc, char** argv) {

	global_value = 5;
	test_func();

	printf("%d\n", global_value); // --> 30

	// --> 2, 3, 4;
	test_static_var();
	test_static_var();
	test_static_var();

	// sizeof()运算能够计算这个变量所占的内存;
	printf("%d\n", sizeof(global_value)); // 变量的类型是int形，占4个字节;
	char ch = '4';
	printf("%d\n", sizeof(ch)); // 变量是一个char类型的变量，占一个字节;
	// sizeof()运算能够计算这个类型所占的内存;
	printf("%d\n", sizeof(int)); // 4个字节;
	printf("%d\n", sizeof(char)); // 1个字节
	// 内存是C语言以及内存大小和管理是C里面核心中的核心;

	// 数组
	// 假设我们需要批量的定义100个int类型的变量; --> 数组
	// 类型(每个元素你的数据类型)  数组名字[批量的个数]
	int array_int[100]; // 定义了一个一个数组，这个数组，能存放 100个整形的数据;
	// 内存大小: int * 100; 4个字节 * 100 = 400个字节;
	printf("array bytes: %d\n", sizeof(array_int));

	// 数组初始化
	int a[] = {1, 2, 3, 4, 5, 6}; // 一个大括号,每个元素的值
	// 自动的去找这个{},有几个值，所以就会定义这个数组的大小为初始化的这几个值;
	printf("a[] = %d\n", sizeof(a));
	// 数组定义，如果没有初始化的，你又没有指定大小，编译就会报错
	// int b[];
	int c[5] = {1, 2, 3}; // 分配了5个int型的数组，可是我只初始化了3个;
	// end

	// 读写，访问
	// 我们访问的时候会对数组里面的每个元素进行一个编号,编号是从0开始;
	// 10个数组的元素: 0 ~9, 6个数组的元素 0 ~5;
	// 数组名字[索引的值] // 范围，[0, 数组的个数 - 1];
	c[3] = 9;
	c[4] = 6;
	printf("%d, %d, %d, %d, %d\n", c[0], c[1], c[2], c[3], c[4]);

	// 索引我们上面是常数，我们还可以以变量作为索引;
	int index = 4;
	printf("c[%d] = %d\n", index, c[index]); // ---> 6;

	// 从0开始, < 数组大小 [0, 大小-1]
	for (int i = 0; i < 5; i++) {
		printf("c[%d] = %d\n", i, c[i]);
	}
	// 注意: 
	// (1)数组一旦定义了，大小就再也不能改变了;
	// (2)数组一旦定义了，元素的个数就定下来了，那么你就只能访问[0, 数组大小 -1]
	// (3)千万不能超过这个范围，否者就会越界,越界的话，程序会发生异常;
	// end 
	int c_array[10]; // [0, 9]
	// c_array[100] = 10; // 错误的做法，因为你访问了，一个非法的内存,写代码的时候一定要小心;
	// 一维数组，一条线这样排下去;

	// 二维数组：数据类型 数组名称[行][列];
	int c_a[3][4]; // 定义了一个 3行4列的二维数组;
	int c_b[3][4] = {
	//   0    1   2  3
		{11, 12, 13, 14}, // 第0行
		{21, 22, 23, 24}, // 第1行
		{31, 32, 33, 34}, // 第2行
	};
	// 二维数组也是一段连续的内存;
	// 索引从0开始
	printf("%d\n", c_b[0][0]);
	printf("%d\n", c_b[1][1]);
	printf("%d\n", c_b[2][0]);
	// end 

	// 遍历所有的行数:
	for (int i = 0; i < 3; i++) {
		// 遍历列数
		for (int j = 0; j < 4; j++) {
			printf("%d ", c_b[i][j]);
		}
		printf("\n");
	}
	// end 

	// 因为内存条是一维，所以二维数组内存上也是1维德，排完一行再排一行;
	system("pause");
	return 0;
}