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;
}