c语言知识盲点记录

1.写出float x 与“零值”比较的if语句——一道面试题分析 -> const float EPSINON = 0.00001; if ((x >= - EPSINON) && (x <= EPSINON)

千万要留意，无论是float还是double类型的变量，都有精度限制，例如：float d1 = 194268.02;在计算机中存储收到精度限制实际保存为194268.015625。所以一定要避免将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。

IEEE 754规定，对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。

　（1）(-1)^s表示符号位，当s=0，V为正数；当s=1，V为负数。

　　（2）M表示有效数字，大于等于1，小于2。

　　（3）2^E表示指数位。

举例来说，十进制的5.0，写成二进制是101.0，相当于1.01×2^2。那么，按照上面V的格式，可以得出s=0，M=1.01，E=2。

十进制的-5.0，写成二进制是-101.0，相当于-1.01×2^2。那么，s=1，M=1.01，E=2。

前面说过，1≤M<2，也就是说，M可以写成1.xxxxxx的形式，其中xxxxxx表示小数部分。IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。比如保存1.01的时候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。

至于指数E，情况就比较复杂。

首先，E为一个无符号整数（unsigned int）。这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，E的真实值必须再减去一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。

比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。

然后，指数E还可以再分成三种情况：

（1）E不全为0或不全为1。这时，浮点数就采用上面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1。

（2）E全为0。这时，浮点数的指数E等于1-127（或者1-1023），有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。

（3）E全为1。这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；如果有效数字M不全为0，表示这个数不是一个数（NaN）。、

例如：

int num=9; /* num是整型变量，设为9 */

float* pFloat=&num; /* pFloat表示num的内存地址，但是设为浮点数 */

定义成int的9直接还原成浮点数，就成了0.000000

首先，将0x0009拆分，得到第一位符号位s=0，后面8位的指数E=00000000，最后23位的有效数字M=000 0000 0000 0000 0000 1001。

由于指数E全为0，所以符合上一节的第二种情况。因此，浮点数V就写成：

　　V=(-1)^0×0.00000000000000000001001×2^(-126)=1.001×2^(-146)

显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是0.000000。

浮点数9.0，如何用二进制表示？还原成十进制又是多少？

首先，浮点数9.0等于二进制的1001.0，即1.001×2^3。

那么，第一位的符号位s=0，有效数字M等于001后面再加20个0，凑满23位，指数E等于3+127=130，即10000010。

所以，写成二进制形式，应该是s+E+M，即0 10000010 001 0000 0000 0000 0000 0000。这个32位的二进制数，还原成十进制，正是1091567616。

2.sizeof 的值是在编译时确定的

如果bai在16位机器上du编译,得到a为2; 直接放在32位机上运行zhidao(假定可以运行,不需移植),得到的还是2.
但如果将源码拿到32位机器上重编,运行后a为4.

sizeof不是函数，而是运算符。

sizeof(n++)等效于sizeof n++，由于n是int，sizeof n++等效于sizeof (int)。

sizeof仅查看其操作数的类型；它不评估表达式。

(除非涉及可变长度数组，但现在我们将忽略它。)

3.未在定义语句中赋初值的auto变量和static变量的初值都是随机值。请问这句话错在哪里？

C语言标准里面，auto变量的初始值没有做要求，一般是随机的，它分到那块bai内存原来是什么，还是什么。

static变量是静态变量，如果定义时未对其赋初值，编译时系统对数值型static变量赋值为0，对字符型变量赋值空。

4.变量的声明和定义的区别

变量定义：用于为变量分配存储空间，还可为变量指定初始值，程序中，变量有且仅有一个定义。

变量声明：用于向程序表明变量的类型和名字。

定义也是声明：当定义变量时我们声明了它的类型和名字。

extern声明不是定义，因为不分配存储空间。extern告诉编译器，变量在其他地方定义了。只有当extern声明位于函数外部时，才可以被初始化。

//是extern声明，也是定义，因为对变量进行了初始化
extern double pi=3.1416; 

一个变量可以在多个地方声明，但是只能在一个地方定义。

5.static变量特点

static修饰的变量
    1. 全局静态变量

    在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。

    1）内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在）

    2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是           任意的，除非他被显示初始化）

    3）作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。

    定义全局静态变量的好处：

    <1>不会被其他文件所访问，修改

    <2>其他文件中可以使用相同名字的变量，不会发生冲突。

    2. 局部静态变量

    在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。

    1）内存中的位置：静态存储区

    2）初始化：未经初始化的局部静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）

    3）作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。

    注：当static用来修饰局部变量的时候，它就改变了局部变量的存储位置，从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对他进行访问。

    当static用来修饰全局变量的时候，它就改变了全局变量的作用域（在声明他的文件之外是不可见的），但是没有改变它的存放位置，还是在静态存储区中。

    三、Static修饰的函数

    在函数的返回类型前加上关键字static，函数就被定义成为静态函数。

    函数的定义和声明默认情况下是extern的，但静态函数只是在声明他的文件中可见，不能被其他文件所用。

    定义静态函数的好处：

    <1> 其他文件中可以定义相同名字的函数，不会发生冲突

    <2> 静态函数不能被其他文件所用。

    存储说明符auto，register，extern，static，对应两种存储期：自动存储期和静态存储期。

    auto和register对应自动存储期。具有自动存储期的变量在进入声明该变量的程序块时被建立，它在该程序块活动时存在，退出该程序块时撤销。

    关键字extern和static用来说明具有静态存储期的变量和函数。用static声明的局部变量具有静态存储持续期（static storage duration），或静态范围（static extent）。虽然他的值在函数调用之间保持有效，但是其名字的可视性仍限制在其局部域内。静态局部对象在程序执行到该对象的声明处时被首次初始化。

    四、总结

    （1）第一个作用：隐藏。

    当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。

    （2）static 的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全 局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。

    （3）static的第三个作用是默认初始化为0。其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。

    最后对static的三条作用做一句话总结。首先static的最主要功能是隐藏，其次因为static变量存放在静态存储区，所以它具备持久性和默认值0。

6.int a[10];a+sizeof(int)=？

此时sizeof（int）为4；而a+4应该指向a【4】的地址

另外数组名是一个常量指针 a++；是错误的

7.c语言内存管理

 

变量概念：
全局变量（外部变量）：出现在代码块{}之外的变量就是全局变量。

局部变量（自动变量）：一般情况下，代码块{}内部定义的变量就是自动变量，也可使用auto显示定义。

静态变量：是指内存位置在程序执行期间一直不改变的变量，用关键字static修饰。
代码块内部的静态变量只能被这个代码块内部访问，代码块外部的静态变量只能被定义这个变量的文件访问。

extern关键字：
1、引用同一个文件中的变量；
2、引用另一个文件中的变量；
3、引用另一个文件中的函数。

注意：C语言中函数默认都是全局的，可以使用static关键字将函数声明为静态函数（只能被定义这个函数的文件访问的函数）。

程序执行流程：

代码区：

　　程序被操作系统加载到内存的时候，所有的可执行代码（程序代码指令、常量字符串等）都加载到代码区，这块内存在程序运行期间是不变的。代码区是平行的，里面装的就是一堆指令，在程序运行期间是不能改变的。函数也是代码的一部分，故函数都被放在代码区，包括main函数。

静态区

　　静态区存放程序中所有的全局变量和静态变量。

栈区
　　栈（stack）是一种先进后出的内存结构，所有的自动变量、函数形参都存储在栈中，这个动作由编译器自动完成，我们写程序时不需要考虑。栈区在程序运行期间是可以随时修改的。当一个自动变量超出其作用域时，自动从栈中弹出。

每个线程都有自己专属的栈；
栈的最大尺寸固定，超出则引起栈溢出；
变量离开作用域后栈上的内存会自动释放。

int main(int argc, char* argv[])
{
    char array_char[1024*1024*1024] = {0};
    array_char[0] = 'a';
    printf("%s", array_char);
    getchar();
}

栈溢出怎么办呢？就该堆出场了。

堆（heap）和栈一样，也是一种在程序运行过程中可以随时修改的内存区域，但没有栈那样先进后出的顺序。更重要的是堆是一个大容器，它的容量要远远大于栈，这可以解决内存溢出困难。一般比较复杂的数据类型都是放在堆中。但是在C语言中，堆内存空间的申请和释放需要手动通过代码来完成。

那堆内存如何使用？

malloc函数用来在堆中分配指定大小的内存，单位为字节（Byte），函数返回void *指针；free负责在堆中释放malloc分配的内存。

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

void print_array(char *p, char n)
{
    int i = 0;
    for (i = 0; i < n; i++)
    {
        printf("p[%d] = %d\n", i, p[i]);
    }
}

int main(int argc, char* argv[])
{
    char *p = (char *)malloc(1024 * 1024 * 1024);//在堆中申请了内存
    memset(p, 'a', sizeof(int)* 10);//初始化内存
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        p[i] = i + 65;
    }
    print_array(p, 10);
    free(p);//释放申请的堆内存
    getchar();
}

这样就解决了刚才栈溢出问题。堆的容量有多大?理论上讲，它可以使用除了系统占用内存空间之外的所有空间。实际上比这要小些，比如我们平时会打开诸如QQ、浏览器之类的软件，但这在一般情况下足够用了。不能将一个栈变量的地址通过函数的返回值返回，如果我们需要返回一个函数内定义的变量的地址该怎么办？可以这样做：

int *getx()
{
    int *p = (int *)malloc(sizeof(int));//申请了一个堆空间
    return p;
}

int main(int argc, char* argv[])
{
    int *pp = getx();
    *pp = 10;
    free(pp);
    return 0;
}
//类似创建链表时，新增一个节点。

可以通过函数返回一个堆地址，但记得一定用通过free函数释放申请的堆内存空间。

分析：

main函数和UpdateCounter为代码的一部分，故存放在代码区

　　数组a默认为全局变量，故存放在静态区

　　main函数中的”char *b = NULL”定义了自动变量b(variable)，故其存放在栈区

　　接着malloc向堆申请了部分内存空间，故这段空间在堆区

需要注意以下几点：

栈是从高地址向低地址方向增长；
在C语言中，函数参数的入栈顺序是从右到左，因此UpdateCounter函数的3个参数入栈顺序是a1、c、b；
C语言中形参和实参之间是值传递，UpdateCounter函数里的参数a[1]、c、b与静态区的a[1]、c、b不是同一个；

内存管理的目的
学习内存管理就是为了知道日后怎么样在合适的时候管理我们的内存。那么问题来了？什么时候用堆什么时候用栈呢？一般遵循以下三个原则：

如果明确知道数据占用多少内存，那么数据量较小时用栈，较大时用堆；

如果不知道数据量大小（可能需要占用较大内存），最好用堆（因为这样保险些）；

如果需要动态创建数组，则用堆。

创建动态数组：

//动态创建数组
int main()
{
    int i;
    scanf("%d", &i);
    int *array = (int *)malloc(sizeof(int) * i);
    //...//这里对动态创建的数组做其他操作
    free(array);
    return 0;
}

操作系统在管理内存时，最小单位不是字节，而是内存页（32位操作系统的内存页一般是4K）。比如，初次申请1K内存，操作系统会分配1个内存页，也就是4K内存。4K是一个折中的选择，因为：内存页越大，内存浪费越多，但操作系统内存调度效率高，不用频繁分配和释放内存；内存页越小，内存浪费越少，但操作系统内存调度效率低，需要频繁分配和释放内存。