C进阶4

▲二维数组参数中第一维的参数可以省略

void f(int a[5])<==>void f(int a[])<==>void f(int* a)
void g(int a[3][3])<==>void g(int a[][3])<==> void g(int (*a)[3])

▲等价关系：

一位数组float a[5]   指针float* a
指针数组int* a[5]    指针的指针int** a
二维数组char a[3][4] 数组的指针char (*a)[4]

▲
C语言中无法向一个函数传递任意的多维数组
必须提供第一维之外的所有维长度；第一维之外的维度信息用于完成指针运算；
N维数组的本质是一维数组，元素是N—1维的数组；对于多维数组只有第一维信息可变。
▲

#include <stdio.h>
void access(int a[][3], int row)
{
    int col = sizeof(*a) / sizeof(int);
    int i = 0;
    int j = 0;
    
    printf("sizeof(a) = %d\n", sizeof(a));
    printf("sizeof(*a) = %d\n", sizeof(*a));
    
    for(i=0; i<row; i++)
    {
        for(j=0; j<col; j++)
        {
            printf("%d\n", a[i][j]);
        }
    }
    
    printf("\n");
}

void access_ex(int b[][2][3], int n)
{
    int i = 0;
    int j = 0;
    int k = 0;
    
    printf("sizeof(b) = %d\n", sizeof(b));
    printf("sizeof(*b) = %d\n", sizeof(*b));
    
    for(i=0; i<n; i++)
    {
        for(j=0; j<2; j++)
        {
            for(k=0; k<3; k++)
            {
                printf("%d\n", b[i][j][k]);
            }
        }
    }
    
    printf("\n");
}

int main()
{
    int a[3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}};
    int aa[2][2] = {0};
    int b[1][2][3] = {0};
    
    access(a, 3);
    access(aa, 2);
    access_ex(b, 1);
    access_ex(aa, 2);
    
    return 0;
}

//------------------------------------------------
如何使用C语言直接跳转到某个固定的地址开始执行？
通过函数指针。
C语言中函数有自己特定的类型，由返回值、参数类型和参数个数决定。

int add(int i,int j)的类型为int (int,int)

C语言中通过typede为函数类型重命名

typedef type name(parameter list)
例：typedef int f(int,int);
    typedef void p(int);

▲

#include <stdio.h>

typedef int(FUNC)(int);

int test(int i)
{
    return i * i;
}

void f()
{
    printf("Call f()...\n");
}

int main()
{
    FUNC* pt = test;
    void(*pf)() = &f;
    
    printf("pf = %p\n", pf);
    printf("f = %p\n", f);
    printf("&f = %p\n", &f);
    
    pf();
    
    (*pf)();
    
    printf("Function pointer call: %d\n", pt(2));
    
    return 0;
}

回调函数是利用函数指针实现的一种调用机制。

函数指针用于指向一个函数，函数名是执行函数体的入口地址；可通过
函数类型定义函数指针：
FuncType* pointer；也可以type (*pointer)(parameter list);
pointer为函数指针变量名，type为所指函数的返回值类型，parameter list为所指函数的参数类型列表。

#include <stdio.h>

typedef int(*Weapon)(int);

void fight(Weapon wp, int arg)
{
    int result = 0;
    
    printf("Fight boss!\n");
    
    result = wp(arg);
    
    printf("Boss loss: %d\n", result);
}

int knife(int n)
{
    int ret = 0;
    int i = 0;
    
    for(i=0; i<n; i++)
    {
        printf("Knife attack: %d\n", 1);
        ret++;
    }
    
    return ret;
}

int sword(int n)
{
    int ret = 0;
    int i = 0;
    
    for(i=0; i<n; i++)
    {
        printf("Sword attack: %d\n", 5);
        ret += 5;
    }
    
    return ret;
}

int gun(int n)
{
    int ret = 0;
    int i = 0;
    
    for(i=0; i<n; i++)
    {
        printf("Gun attack: %d\n", 10);
        ret += 10;
    }
    
    return ret;
}

int main()
{
    fight(knife, 3);
    fight(sword, 4);
    fight(gun, 5);
    
    return 0;
}

//----------------------------------------------

int (*p)(int):p为指针，指向函数，指向的函数有一个int参数，返回值为int。

int (*p1)(int*,int(*f)(int*)):p1为指针，指向函数；指向的函数有int*，f为第二个参数，它是函数指针，
指向的参数时int*，返回值是int，返回值是int。
int (*p2[5])(int*):p2为数组，有5个元素，这5个元素为指针，指向函数，函数类型为int（int*）。
int (*(*p3)[5])(int*):p3为指针，数组指针，指向的数组有5个元素，这5个元素为指针，该指针是函数指针，指向的函数类型为int（int*）
int* (*(*p4)(int*))(int*):p4为指针，函数指针，参数为int*，返回值为指针，函数指针，指向的函数类型int*（int*）
int (*(*p5)(int*))[5]:p5为指针，指向函数，函数指针参数为int*，返回值为指针，指向数组，指向的数组类型为int[5]

typedef int(ArrayType)[5];
typedef ArrayType*(FuncType)(int*);
FunType* p5;

//------------------------------------------
动态内存分配
malloc0将返回什么？合法。
malloc0不释放后果？产生内存泄漏。
//-------------------------------------------
堆和栈和静态存储区
栈：主要用于函数调用的使用，不要返回局部变量的地址。
堆：内存的动态申请和归还；堆中被程序申请使用的内存在被主动释放前将一直有效。
静态存储区:全局变量和静态变量
为什么有了栈还需要堆？答：栈上的数据在函数返回后就会被释放掉，无法传递到函数外部，如局部数组。
注：空闲链表法、位图法、对象池法。malloc free。

#include <stdio.h>

int g_v = 1;

static int g_vs  = 2;

void f()
{
    static int g_vl = 3;
    
    printf("%p\n", &g_vl);
}

int main()
{
    printf("%p\n", &g_v);
    
    printf("%p\n", &g_vs);
    
    f();
    
    return 0;
}

注：3个变量的地址是挨着的。
//-------------------------------------------------
程序的内存布局：

▲程序和进程不同：
程序是静态的概念，表现形式为一个可执行文件
进程是动态的概念，程序由操作系统加载运行后得到进程
每个程序可以对应多个进程；每个进程只能对应一个程序。
▲包含脚本代码的文本文件是一种类型的可执行程序吗？如果是，对应什么样的进程呢？

▲堆栈段在程序运行后才正式存在，是程序运行的基础

.bss段存放的是未初始化的全局变量和静态变量
.text段存放的是程序中的可执行代码
.data段保存的是已经初始化了的全局变量和静态变量
.rodata段存放程序中的常量值，如字符串常量

▲
静态存储区通常指程序中的.bss和.data段
只读存储区通常指程序中的.rodata段
局部变量所占空间为栈上的空间
动态空间为堆中的空间
程序可执行代码存放于.text段

问：同是全局变量和静态变量，为什么初始化的和未初始化的保存在不同段中？

C规定，未初始化变量的初值为0，这个清0的操作是由启动代码完成的，还有已初始化变量的初值的设置，也是由启动代
码完成的。为了启动代码的简单化，编译链接器会把已初始化的变量放在同一个段：.data，这个段的映像（包含了各个
变量的初值）保存在“只读数据段”，这样启动代码就可以简单地复制这个映像到 .data 段，所有的已初始化变量就都初
始化了。而未初始化变量也放在同一个段：.bss，启动代码简单地调用 memset 就可以把所有未初始化变量都清0。

//-----------------------------------------------------
内存操作经典问题：
野指针的由来：局部指针变量没有初始化；指针所指向的变量在指针之前被销毁；
使用已经释放过得指针；进行了错误的指针运算；进行了错误的强制类型转换；
基本原则：
绝不返回局部变量和局部数组的地址；任何变量在定义后必须0初始化；
字符数组必须确认0结束符后才能成为字符串；任何使用与内存操作相关的函数必须指定长度信息；

#include <stdio.h>
#include <malloc.h>


int main()
{
    int* p1 = (int*)malloc(40);
    int* p2 = (int*)1234567;      //error
    int i = 0;
    
    for(i=0; i<40; i++)
    {
        *(p1 + i) = 40 - i;
    }

    free(p1);    //并不会将指针置为空
    
    for(i=0; i<40; i++)
    {
        p1[i] = p2[i];  // 使用已经释放了的内存空间
    }
    
    return 0;
}

常见内存错误：

结构体成员指针未初始化；结构体成员指针未分配足够的内存；内存分配成功，但并未初始化；内存操作越界；
内存错误的本质源于指针保存的地址为非法值；指针变量未初始化，保存随机值；指针运算导致内存越界；
内存泄漏源于malloc和free不匹配；

//-----------------------------------------------
函数：
函数的参数在栈上分配空间；函数的实参并没有固定的计算次序；顺序点是C语言中变量修改的最晚时机；
C语言中可以定义参数可变的函数：参数可变函数的实现依赖于stdarg.h头文件
va_list参数集合；va_start标识参数访问的开始；va_end标识参数访问的结束；
●可变参数必须从头到尾按照顺序逐个访问，参数列表中至少要存在一个确定的命名参数，可变参数函数无法确定实际存在的参数的数量，
可变参数函数无法确定参数的实际类型；
注：va_arg中如果指定了错误的类型，结果不可预测。
调用约定指定了函数参数的入栈顺序以及栈的清理方式；可变参数必须顺序的访问，无法直接访问中间的参数值；

#include <stdio.h>
#include <stdarg.h>

float average(int n, ...)
{
    va_list args;
    int i = 0;
    float sum = 0;
    
    va_start(args, n);
    
    for(i=0; i<n; i++)
    {
        sum += va_arg(args, int);
    }
    
    va_end(args);
    
    return sum / n;
}

int main()
{
    printf("%f\n", average(5, 1, 2, 3, 4, 5));
    printf("%f\n", average(4, 1, 2, 3, 4));
    
    return 0;
}

//----------------------------------------------------