存储类别

int a = 1;
int *p = &a;
int ranks[10];

首先我们定义一下对象，他是指一块内存。他可以存储一个或者多个值。
我们可以看到，变量名a是一个标识符，表示一个变量，他是一个对象。
而p这个标识符，他指定了一个存储地址的对象。
ranks声明了一个可容纳10个元素的对象。该数组每个元素也是一个对象。

不同的存储类别具有三种特性，存储期，作用域，链接。

定义、声明和初始化的区别

一般的情况下，我们把建立空间的声明称之为定义，而把不需要建立存储空间的声明称之为声明。
变量的初始化，就很简单了，为变量声明或者定义之后，赋上初值的过程，就是变量的初始化。

tern被声明了两次，
第一次声明为变量预留了存储空间构成了定义。称为定义式声明。
第二次声明只是使用之前的变量，而没有创建空间所以仅仅是声明。

定义和初始化的区别：
int a; 只是定义并没有付初始值，所以不是初始化。
int a = 4 既是定义又是初始化。
extern int a; 仅仅是声明。
extern关键字只能做声明，不能定义。

当然定义和初始化也可以分开

int b; //定义变量
b = 2； //初始化变量

作用域

C变量作用域：表示变量的作用范围，空间维度
有四种：

1. 块作用域：局部变量都具有块作用域。
2. 函数作用域：仅用于goto语句，一般很少。
3. 函数原型作用域：形参，形参定义到函数结束。
4. 文件作用域：直接定义在源文件中的变量，具有文件作用域。所以具有文件作用域的变量称为全局变量。

翻译单元和文件

编译器会把源代码文件和所有包含的的头文件都看成是一个包含信息的单独文件，这个文件被称为一个翻译单元。描述一个文件作用域的变量时，他实际的可见范围是整个翻译单元。
所以一个翻译单元是一个源文件和他所有包含的所有头文件。

链接属性

C变量有三种链接属性：

1. 外部链接
2. 内部链接
3. 无链接

局部变量都是无链接的属性。只有全局变量有外部链接和内部链接两种属性。
我们现在看一下全局变量：

变量具有外部链接属性：他可以在文件外部使用，也就是多文件程序中使用，也叫全局作用域或者程序作用域。
内部链接属性：static修饰的，只在本文件生效，简称文件作用域。

存储期

存储期顾名思义是是变量存在的时间维度。而作用域表示空间维度。这里注意区分。

举个简单的例子就是函数的局部变量分配的int a = 0;他会随着函数销毁自动释放。而malloc分配的变量会等到手动free的时候才会释放。

C变量有四种存储期：

1. 静态存储期：程序运行期一直存在。全局变量具有静态存储期，不管是全局作用域还是文件作用域的变量**（带不带static的变量）都在程序运行时一直存在**。static修饰的局部变量也有静态存储期，在块销毁的时候他还存在，但是只有在块内才能访问到他。
2. 线程存储期：具有线程存储期的变量，以_Thread_local声明的变量，存在于整个线程的生命周期中。
3. 自动存储期：块作用域的局部变量，在块作用域内，块结束会自动释放变量内存。
4. 动态分配存储期：malloc，和free，用户自己管理。

存储类别

所以下面我们主要区别，一个变量有五种存储类别，我们在声明时变量会属于其中一种。

1. 自动存储期：程序运行到块内该变量声明时存在，退出时消失，占用的内存也被释放可另作他用。自动变量声明时就占用内存，而如果没有初始化，那么他的值为该块内存之前使用的值，所以是非预期值，记得在使用前一定要初始化或者赋值。
2. 寄存器存储：这样的变量使用register关键字，直接存储到寄存器中，但是无法获取该变量的地址。但是编译器可能并不会直接分配真正的寄存器给你，那他和普通变量就一样了，但是还是不能使用该变量的地址。
3. 块内static：该变量在每次函数调用的时候会记录该值。该变量在程序运行时一直存在内存中。函数的形参中不允许使用static
4. 文件作用域的static变量：该变量作用范围只在翻译单元中，但是生命周期是整个程序。
5. 全局作用域变量：也就是不带static的变量为了指出该变量是外部变量，
   在同一个翻译单元中：我们在使用外部变量可以在前面加上extern关键字，作为声明。
   如果不加这个extern 关键字，又声明了一次，那就表示我又创建了一个局部变量在函数中，这会隐藏外部变量。
   当然我也可以不声明，在同一个翻译单元中直接使用即可。
   如果在不同翻译单元中：也可加extern作为声明引用此外部变量。因为外部变量作用范围是整个程序。
   外部变量默认被初始化为0.

多文件共享全局变量

所以多个翻译单元中，使用全局变量作为共享，则在其中一个翻译单元定义一个变量，在其他翻译单元中进行使用该变量之前先使用extern声明该变量，如果不使用extern声明，则不能使用该变量，因为找不到。
extern关键字表示声明的变量在别处。

函数的存储类别

有两种：外部和内部，外部指全局，内部指翻译单元内。

首先第一个表示声明了该函数，并且该函数默认为外部，那么其他所有翻译单元都可以使用。其实这里省略了extern关键字，所以和第三个函数是一样的。
第三个函数显示声明了extern，通常做法这样写表明该函数声明在了其他翻译单元中。但是一般做法是如果要使用某个函数，就把他的头文件包含进来，也就是在当前翻译单元声明了该函数，一起编译就可以直接使用了。
static修饰的函数，只能用于当前翻译单元，

存储类别的选择

默认的而且优先都是选择自动存储类别。
非必要不要声明和定义全局变量，因为他可能被其他人修改而造成你无法正常使用。
除非一种const修饰的全局变量，他在初始化后就不会被修改。

分配内存（malloc、free）

上面的内存分配与回收都是系统帮我们做了，而我们不用管。如果我们想自己更灵活的分配和回收内存可以使用malloc和free。
需要引入#include <stdlib.h>库头文件，内存分配函数在这里面。

malloc和calloc

malloc(size)
给malloc一个参数，表示要申请的内存大小，所需的byte数。
malloc会找到一块空闲内存，返回内存块的首字节地址，所以可以把该地址赋值给一个指针，后面可以使用该指针访问这块内存。
返回值类型是一个void类型的指针，该类型相当于一个通用指针，该指针通常被强转为一个匹配的类型并不需要考虑类型不匹配的问题，并且我们应该坚持这样做来保证代码的可读性，C中虽然不要求强制转换，但是C++中必须使用，那么我们坚持这样做来保证可移植性。

如果malloc分配内存失败，则他会返回一个空指针nullptr，我们可以通过是否为空指针来判断是否成功分配了内存。

double *pt = (double *) malloc (30 * sizeof(double));

这段代码为30个double类型的值申请了一块内存，并设置pt指向该内存首元素地址。
回忆一下，数组名为该数组的首元素地址。所以pt指向该块内存的首元素，那么我们可以用数组名来使用它。可以使用数组名来表示指针，也可以使用指针来表示数组名。
我们可以使用pt[0]来访问该块的首元素，pt[1]来访问第二个元素。

long* num;
num = (long *)calloc(100, sizeof(long));

calloc第一个参数是存储单元数量，第二个参数是存储单元大小。
他的返回值也是void* 需要强转成需要的类型。
他还有一个特性是会把分配后的所有值都初始化为0.

创建数组方式

所以现在我们有两种方式创建数组
第一种：double item[30];
第二种：

int n = 6; 
double *pt = (double *) malloc(n * sizeof(double));

第一种我们必须指定一个常量作为数组的大小。
而第二种的优势是我们可以创建一个变长数组。
使用malloc在运行时才确定内存数组的大小。

#include <stdio.h>
#include <stdlib.h> /* for malloc(), free() */

int main(void)
{
    double * ptd;
    int max;
    int number;
    int i = 0;
    
    max = 6;
    ptd = (double *) malloc(max * sizeof (double)); //分配动态数组
    if (ptd == NULL) //如果分配失败则退出
    {
        puts("Memory allocation failed. Goodbye.");
        exit(EXIT_FAILURE);//异常退出程序
    }
    /* ptd now points to an array of max elements */
    puts("Enter the values (q to quit):");
    while (i < max && scanf("%lf", &ptd[i]) == 1)
        ++i;
    printf("Here are your %d entries:\n", number = i);
    for (i = 0; i < number; i++)
    {
        printf("%7.2f ", ptd[i]); //使用指针也即数组名访问元素
        if (i % 7 == 6)
            putchar('\n');
    }
    if (i % 7 != 0)
        putchar('\n');
    puts("Done.");
    free(ptd);//释放内存
    
    return 0;
}

free的重要性

我们使用free函数来释放malloc分配的内存，free接受参数为malloc返回的指针。
当不断分配内存而忘记释放，可能会耗尽内存，这类问题称为内存泄漏。

举例

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

int static_store = 30;
const char * pcg = "String Literal";
int main()
{
    int auto_store = 40;
    char auto_string[] = "Auto char Array";
    int * pi;
    char * pcl;
    
    pi = (int *) malloc(sizeof(int));
    *pi = 35;
    pcl = (char *) malloc(strlen("Dynamic String") + 1);
    strcpy(pcl, "Dynamic String");
    
    printf("static_store: %d at %p\n", static_store, &static_store);
    printf("  auto_store: %d at %p\n", auto_store, &auto_store);
    printf("         *pi: %d at %p\n", *pi, pi);
    printf("  %s at %p\n", pcg, pcg);
    printf(" %s at %p\n", auto_string, auto_string);
    printf("  %s at %p\n", pcl, pcl);
    printf("   %s at %p\n", "Quoted String", "Quoted String");
    free(pi);
    free(pcl);
    
    return 0;
}
// static_store: 30 at 0x601048     静态区域
//   auto_store: 40 at 0x7fff5f25f8dc   自动区域
//          *pi: 35 at 0xeea010     堆
//   String Literal at 0x4007a0     静态区域
//  Auto char Array at 0x7fff5f25f8c0   自动区域
//   Dynamic String at 0xeea030     堆
//    Quoted String at 0x40080e     静态区域