20160211.CCPP体系详解(0021天)

程序片段(01):01.指针数组.c+02.动态数组.c
内容概要:指针数组

///01.指针数组.c#include <stdio.h>#include <stdlib.h>//01.指针数组作为函数的形参://  会退化为一个二级指针!//02.如何确定一个数组作为函数形参将会退化为什么样儿的指针?//  关键在于形参数组当中的元素是什么类型!就是什么类型的指针void show01(char * str[5])//char *str[5]{    for (int i = 0; i < 5; ++i)    {        printf("%s \n", str[i]);//char **str    }}//03.等价关系://  二级指针和指针数组的数组名所对应的解析方式都一样!void show02(char ** str){//指针数组作为函数的形参进行传参的时候,指针数组的数组名将会退化为一个二级指针!    for (int i = 0; i < 5; ++i)    {        printf("%s \n", str[i]);    }}//04.函数形参的拦截机制://  如果是数组,就没有副本机制,不是副本,就有拦截介质//注:解除数组的副本机制依赖于数组名的退化机制!//05.如何确定一个变量的数据类型?//  在定义变量的基础情况之下,挖掉变量名,就是变量的数据类型//注:字符指针数组开发过程当中比较常用!int main01(void){    int * arr[10];//-->int * [10]-->一级指针数组类型!    //一级指针数组的数组名arr在作为函数形参的时候,该一级指针的数组名会自动退化以为一个二级指针    char * str[5] = { "calc", "notepad", "tasklist", "mspaint", "pause" };    //char * [N]:字符指针类型的一级指针数组在开发过程当中经常使用!    char **pp = str;//变量指针=常量指针(地址意义的数组赋值动作!)-->指针变量结果-->指针变量遍历!    printf("%p \n", str);//二级指针常量的数值    //show01(str); <= = > show02(str);    system("pause");}

///02.动态数组.c#include <stdio.h>#include <stdlib.h>//01.如何确定动态数组的数组名称?//  1.开辟内存的时候所采用的指针变量名称就是动态数组名称!//  2.通过指针变量名称的访问方式就如同标准数组的访问方式!//  注:严格区分变量指针和常量指针之间的差别!int main02(void){    //动态分配一个一维数组    int * const arr = malloc(30 * sizeof(int));    for (int i = 0; i < 30; ++i)    {        printf("%d \n", arr[i] = i);//arr[i]<=>*(arr+i)    }    system("pause");}//02.动态数组的分配要点://  1.动态内存开辟函数!//  2.解析动态内存的指针类型!//  注:所有数组都看做为一维数组!,指向该数组首元素的指针//      指针可以使用:变量指针和常量指针(模拟栈内存数组!)//  注:动态数组的尺寸在程序运行过程当中决定!//      每个当前维度的数组都必须要求明确其维度-1的特点int main03(void){    //动态分配一个二维数组    //int test = 5;    int(*p)[5] = malloc(30 * sizeof(int));    for (int i = 0, num = 0; i < 30; ++i, ++num)    {        printf("%3d", p[i / 5][i % 5] = num);//0->1->2->3...        if (0 == (i + 1) % 5)            putchar('\n');    }    system("pause");}//03.两种区别的数组://  二维数组:数组当中的每个相邻数组元素的内存地址必须连续//      (连续!+对齐!)//  分块数组:针对于同一个数组当中的每个数组元素的内存地址必须连续//      但是内部就整体而言的数组元素之间是可以不连续的//      (不连续+不对齐!)//  注:动态内存开辟函数的返回值类型为("void *")类型,只是负责返回一个有效//      地址,但是没有具备解析意义+堆内存动态开辟函数前面的赋值号只是用于//      返回一个明确的地址而已!-->指针类型决定对动态内存的实际解析意义!int main04(void){    //使用malloc函数在堆内存当中开辟一个指针数组!    int **pp = malloc(5 * sizeof(int *));//20个堆内存字节    int num = 0;    for (int i = 0; i < 5; ++i)    {        pp[i] = (int *)malloc((5 + i)*sizeof(int));        for (int j = 0; j < 5 + i; ++j)        {            pp[i][j] = num++;//赋值        }    }    for (int i = 0; i < 5; ++i)    {        for (int j = 0; j < 5 + i; ++j)        {            printf("%3d", pp[i][j]);        }        printf("\n");    }    system("pause");}//04.常见数据结构的特点://  数组:查找效率高+增加|删除效率低//  链表:增加|删除效率高+查找效率低//  分块:查找效率和数组一样+增加|删除效率比数组高(略低于链表,不过可以忽略!)//      可以不用连续,可以不用对齐!//05.如何分配一个N-1级指针数组?//  需要一个N级的指针!// N级指针,存储N-1级指针数组的地址// N级指针分配一个数组,用于存放N-1级指针数组的首个元素的地址(区分变量指针|常量指针)// 数据等同于0级指针

程序片段(02):01.Array.c
内容概要:数组的三种形态

#include <stdio.h>#include <stdlib.h>//01.C语言版本标准://  第一版:C89//  第二版:C99//02.(VC2013以上+GCC4.7以上)支持C99语法//  VC2013+GCC4.7//03.C99新语法分配数组模式!//  1.位于栈内存的静态数组//  2.可以进行指明初始化!//      指明初始化的最大索引可以推导数组总元素个数//  3.指明初始化方式的特点:可以明确长度!//      纯大括号初始化:只能同时指明数组长度,并且给数组最后一个元素初始化赋值//          其余数组元素统统采用默认初始化方式!//      非纯大括号初始化:可以同时指明数组长度,并且给多个数组元素初始化赋值//          其余数组元素统统采用默认初始化方式!int main01(void){    int arr[] = { [10] = 10 };//默认不操作的数组元素被赋值为0,[10]-->arr[10]=0->11个元素    for (int i = 0; i < 11; ++i)    {        printf("%d \n", arr[i]);    }    system("pause");}int main02(void){    int n = 4;    int * pC99 = (int[]) { [2] = 1, [4] = 10 };//静态数组    //默认不指明初始化的数组元素所对应的值为0    for (int i = 0; i < 5; ++i)    {        printf("%d \n", pC99[i]);    }    system("pause");}//04.静态数组与动态数组://  静态数组://      1.存储于栈内存//      2.编译时期决定数组元素个数//      3.(自动开辟+自动回收)//  动态数组://      1.存储于堆内存//      2.运行时期决定数组元素个数//      3.(手动开辟+手动释放)//  注:严格区分(分配+释放)以及(开辟+回收)的区别//      分配+释放:权限//      开辟+回收:内存void run(){    //int arr[5] = { 1, 2, 3, 4, 5 };    int * p = malloc(10 * sizeof(int));    for (int i = 0; i < 10; ++i)    {        p[i] = i;//p[i]-->*(p+i)    }    free(p);    //基于C99语法的静态数组:处于栈内存当中,自动开辟回收,用于解决心脏起搏器问题!    //int * pC99 = (int []){ [4] = 10 };    //printf("%p \n", pc99);    printf("\n");}int main03(void){    run();    printf("\n\n\n");//加速内存的回收动作!+防止Release模式!优化操作    run();    printf("\n\n\n");    system("pause");}//05.指针变量可以指向任何内存地址://  无论是栈内存,堆内存,全局区,代码区int main04(void){    int num = 30;    //int * pC99 = (int[30]) { 0 };    //pC99 = (int[10]) {0};//pC99是int*类型    //pc99 = 1;    int * pC99 = (int [30]) { [2] = 1, [4] = 10 };//静态数组    for (int i = 0; i < 30; ++i)    {        printf("%d \n", pC99[i]);    }    system("pause");}//06.区分静态分配和动态分配区别://  int num=30;//静态分配:必须在编译时期,决定静态数组的元素个数//  int a[num];//栈上的静态分配-->可变长度的数组只有在GCC编译器当中实现,VC编译器当中不能进行实现//  注:VC不支持位于栈内存的静态数组+GCC支持位于栈内存的静态数组!

程序片段(03):01.内存.c
内容概要:四大分配堆内存的函数

#include <stdio.h>#include <stdlib.h>//01.内存四大分配函数://  malloc<->calloc://      malloc:内存不清零(参数:内存字节数)//      calloc:内存清零(参数1:数组元素个数+参数2:单个元素尺寸)//  realloc<->_recalloc://      realloc:内存不清零(参数1:内存首地址,总内存字节数)//          1.如果原始内存地址足够拓展,就在原始内存地址进行拓展//          2.如果原始内存地址不够拓展,就在新地址内存进行拓展://              拷贝原始内存地址所对应的有效数据+回收原始内存地址数据//          3.拓展之后的内存如果没有数据进行覆盖,就不回执行内存清零操作!//      _recalloc:内存清零(参数1:内存首地址+参数2:数组元素个数+参数3:单个元素尺寸)//          1.如果原始内存地址足够拓展,就在原始内存地址进行拓展//          2.如果原始内存地址不够拓展,就在新地址内存进行拓展//              拷贝原始内存地址所对应的有效数据+回收原始内存地址数据//          3.拓展之后的内存如果没有进行手动初始化,系统将会执行自动初始化操作!int main01(void){    //int * p = (int *)malloc(100);//malloc不会初始化参数,参数是整体所占用的内存尺寸(字节数)!    int * p = calloc(25, sizeof(int));//calloc存在初始化参数,参数解释:第一个参数是元素个数,第二个参数是元素内存尺寸    printf("%p \n", p);    //for (int i = 0; i < 25; ++i)    //{    //  p[i] = i;    //}    system("pause");}int main02(void){    int * p = malloc(10 * sizeof(int));//指针能够操作这片儿堆内存!    //int * p_p = malloc(100);    for (int i = 0; i < 10; ++i)    {        printf("%d \n", p[i] = i);    }    printf("p = %p \n", p);    int * px = realloc(p, 200);//拓展内存,内存不清零    //返回值是内存首地址,说明拓展成功,后续地址拓展,拓展不成功,重新开辟内存    //原来的内存就被回收了    printf("px = %p \n", px);    for (int i = 0; i < 50; ++i)    {        px[i] = i;        printf("%d \n", px[i]);    }    //p[120387] = 10;    system("pause");}int main03(void){    int * p = calloc(25, sizeof(int));//会初始化为0,参数:数组元素个数+内存字节大小    //scanf("123");    printf("%p \n", p);    for (int i = 0; i < 25; ++i)    {        p[i] = i;    }    p = _recalloc(p , 50, sizeof(int));//内存清零操作    for (int i = 25; i < 50; ++i)    {        p[i] = i;    }    system("pause");}

程序片段(04):main.c
内容概要:GccArray

#include <stdio.h>#include <stdlib.h>//01.VC不支持栈内存动态数组,GCC支持栈内存动态数组!int main(){    int num=30;    int a[num];//栈上的动态分配     //int *pc99 = (int[30]){0};    //printf("Hello world!\n");    return 0;}