C语言进阶之指针的进阶

---

1. 字符指针
2. 数组指针
3. .指针数组
4. 数组传参和指针传参
5. 函数指针
6. 函数指针数组
7. 指向函数指针数组的指针
8. 回调函数
9. 指针和数组面试题的解析

---

1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。

3. 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。 4. 指针的运算。

一. 字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* ;

一般使用:

int main()
{
    char ch = 'w';
    char *pc = &ch;
    *pc = 'w';
    return 0;
}

还有一种使用方式如下：

int main()
{
    const char* pstr = "hello bit.";
    //无论有无const该字符串常量都放在内存中的只读数据区，不可更改
    //因此*pstr也无法被赋予新值
    printf("%s\n", pstr);
    return 0;
}

代码 const char* pstr = "hello bit.";

特别容易以为是把字符串 hello bit 放到字符指针 pstr 里了，但是本质是把字符串 hello bit. 首字符的地址放到了pstr中。

 上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。

那就有可这样的面试题：

#include 
int main()
{
    char str1[] = "hello bit.";//两个不同的数组
    char str2[] = "hello bit.";//数组名代表首元素地址

    const char *str3 = "hello bit.";//存的是字符串常量的首元素地址
    const char *str4 = "hello bit.";//字符串常量不可更改

    if(str1 == str2)//两个首元素地址不同
         printf("str1 and str2 are same\n");
    else
         printf("str1 and str2 are not same\n");
       
    if(str3 == str4)//两个指针所指向的内存区域一致
         printf("str3 and str4 are same\n");
    else
         printf("str3 and str4 are not same\n");
       
    return 0;
}
//综上所述，一个比的是数组首元素的地址，一个比的是指针所指向的地方是字符串常量首元素的地址

这里最终输出的是：

 这里str3和str4指向的是一个同一个常量字符串。

C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。

但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。

所以str1和str2不同，str3和str4不同。

PS：#define定义的指针只能管到最近的一个，因为仅仅只是代换了，int之类的数据类型可以共用，但是 * 无法共用，要注意如何连续定义多个指针，如下：

#define PINT int*
int main(){

    PINT pa, pb;//这样定义只是把pa定义为int*，pb仍然为int

        PINT pa, *pb//这样才是把两个都定义为指针

            return 0;
}

       但是使用typedef可以，因为使用typedef的效果如同再次重新命名了之前的类型，产生的是一个新的类型名，如下：

typedef int* pint;

int main(){

    pint pa, pb;//此时两个都是指针

        return 0;
}

二. 指针数组

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

如下：

int main(){

    char* arr[] = {"wangwu", "lisi", "zhangshan"};
    //arr指针数组中存放的是每个字符串中首字符的地址
        
        char a = *(*(arr+2)+2);
        //即可访问i

            return 0;
}

三. 数组指针

1. 数组指针的定义

数组指针是指针？还是数组？

答案是：指针。

我们已经熟悉：

整形指针： int * pint; 能够指向整形数据的指针。

浮点型指针： float * pf; 能够指向浮点型数据的指针。

那数组指针应该是：能够指向数组的指针。

下面代码哪个是数组指针？

int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？

解释：

int (*p)[10];

解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个 指针，指向一个数组，叫数组指针。

这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

2. &数组名VS数组名

对于下面的数组：

int arr[10];

arr 和 &arr 分别是啥？

我们知道arr是数组名，数组名表示数组首元素的地址。

那&arr数组名到底是啥？

我们看一段代码：

#include 
int main()
{
    int arr[10] = {0};
    printf("%p\n", arr);
    printf("%p\n", &arr);
    return 0;
}

运行结果如下：

 可见数组名和&数组名打印的地址是一样的。

难道两个是一样的吗？

我们再看一段代码：

#include 
int main()
{
 int arr[10] = { 0 };
 printf("arr = %p\n", arr);
 printf("&arr= %p\n", &arr);
 printf("arr+1 = %p\n", arr+1);
 printf("&arr+1= %p\n", &arr+1);
 return 0;
}

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。

实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）

本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型

数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40. 

3. 数组指针的使用

那数组指针是怎么使用的呢？

既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。

看代码：

#include 
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
    //但是我们一般很少这样写代码
    return 0;
}

一个数组指针的使用：

#include 
void print_arr1(int arr[3][5], int row, int col)
{
    int i = 0;
    for(i=0; i

学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：

int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];

四. 数组参数、指针参数

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

1. 一维数组传参

#include 
void test(int arr[])//可以（可以不指明元素个数）
{}
void test(int arr[10])//可以
{}
void test(int *arr)//可以（指针接收）
{}
void test2(int *arr[20])//可以（指针数组接收）
{}
void test2(int **arr)//可以（数组元素为指针，用二级指针接收）
{}
int main()
{
 int arr[10] = {0};
 int *arr2[20] = {0};//指针数组
 test(arr);
 test2(arr2);
}

2. 二维数组传参

void test(int arr[3][5])//可以
{}
void test(int arr[][])//不可以（必须指明列）
{}
void test(int arr[][5])//可以
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//不可以
{}
void test(int* arr[5])//不可以
{}
void test(int (*arr)[5])//可以（数组指针接收二维数组）
{}
void test(int **arr)//
{}
int main()
{
 int arr[3][5] = {0};//二维数组一般用数组指针接收
 test(arr);
}

3. 一级指针传参

#include 
void print(int *p, int sz)
{
 int i = 0;
 for(i=0; i

思考：

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

比如：

void test1(int *p)
{}
//test1函数能接收地址，一级指针，一维数组数组名 
void test2(char* p)
{}
//test2函数能接收字符串数组数组名，字符地址，字符指针

4. 二级指针传参

#include 
void test(int** ptr)
{
 printf("num = %d\n", **ptr); 
}
int main()
{
 int n = 10;
 int*p = &n;
 int **pp = &p;
 test(pp);
 test(&p);
 return 0;
}

思考：

当函数的参数为二级指针的时候，可以接收什么参数？

void test(char **p)
{
 
}
int main()
{
 char c = 'b';
 char*pc = &c;
 char**ppc = &pc;
 char* arr[10];
 test(&pc);
 test(ppc);
 test(arr);//可以，arr里的元素是一级指针
 return 0;
}

五. 函数指针

首先看一段代码：

#include 
void test()
{
 printf("hehe\n");
}
int main()
{
 printf("%p\n", test);
 printf("%p\n", &test);
 return 0;
}

输出的结果：

输出的是两个地址，这两个地址是 test 函数的地址。

那我们的函数的地址要想保存起来，怎么保存？

下面我们看代码：

void test()
{
 printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

首先，能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？

答案是：

pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参 数，返回值类型为void。

PS：函数指针的 * 和 & 是可以省略的，但是如果不省略 * 的话注意需要加上()

int Add(int x, int y)
{
    return x + y;
}

int main()
{
    int x = 0;
    int y = 0;
    scanf("%d %d", &x, &y);
    int (*pf) (int, int) = &Add;
    int (*pf) (int, int) = Add;
    int sum = (*pf)(x,y);
    int sum2 = pf(x,y);
    printf("%d %d\n", sum, sum2);
    return 0;
}

阅读两段有趣的代码：

//代码1
(*(void (*)())0)();

//void (*)() 表示这个是一个函数指针
//（void (*)()）0 则表示将0（int类型）强制转化为函数指针类型
//( *( void (*)() )0 ) (); 表示解引用该函数指针并调用0地址处的函数
//所以本质上是函数调用


//代码2
void ( *signal( int , void (*)(int) ) ) (int);

//signal( int , void (*)(int) )表明signal是一个函数
//包含一个int类型的参数和函数指针类型的参数
//void ( *) (int) 表示其返回类型为一个函数指针类型
//所以本质上是函数声明

代码2太复杂，如何简化：

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

六. 函数指针数组

数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，

比如：

int *arr[10];
//数组的每个元素是int

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];

答案是：parr1

parr1 先和 [] 结合，说明 parr1是数组，数组的内容是什么呢？

是 int (*)() 类型的函数指针。

函数指针数组的用途：转移表

例子：（计算器）

#include 
int add(int a, int b)
{
 return a + b;
}
int sub(int a, int b)
{
 return a - b;
}
int mul(int a, int b)
{
 return a*b;
}
int div(int a, int b)
{
 return a / b;
}
int main()
{
 int x, y;
 int input = 1;
    int ret = 0;
    do
   {
        printf( "*************************\n" );
        printf( " 1:add           2:sub \n" );
        printf( " 3:mul           4:div \n" );
        printf( "*************************\n" );
        printf( "请选择：" );
        scanf( "%d", &input);
        switch (input)
       {
        case 1:
              printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = add(x, y);
              printf( "ret = %d\n", ret);
              break;
        case 2:
              printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = sub(x, y);
              printf( "ret = %d\n", ret);
              break;
        case 3:
              printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = mul(x, y);
              printf( "ret = %d\n", ret);
              break;
        case 4:
              printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = div(x, y);
              printf( "ret = %d\n", ret);
              break;
        case 0:
                printf("退出程序\n");
 breark;
        default:
              printf( "选择错误\n" );
              break;
       }
 } while (input);
    
    return 0;
}

使用函数指针数组的实现：

#include 
int add(int a, int b)
{
           return a + b;
}
int sub(int a, int b)
{
           return a - b;
}
int mul(int a, int b)
{
           return a*b;
}
int div(int a, int b)
{
           return a / b;
}
int main()
{
     int x, y;
     int input = 1;
     int ret = 0;
     int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
     while (input)
     {
          printf( "*************************\n" );
          printf( " 1:add           2:sub \n" );
          printf( " 3:mul           4:div \n" );
          printf( "*************************\n" );
          printf( "请选择：" );
      scanf( "%d", &input);
          if ((input <= 4 && input >= 1))
         {
          printf( "输入操作数：" );
              scanf( "%d %d", &x, &y);
              ret = (*p[input])(x, y);
         }
          else
               printf( "输入有误\n" );
          printf( "ret = %d\n", ret);
     }
      return 0;
}

七. 指向函数指针数组的指针

指向函数指针数组的指针是一个 指针

指针指向一个 数组 ，数组的元素都是 函数指针 ;

如何定义？

void test(const char* str)
{
 printf("%s\n", str);
}
int main()
{
 //函数指针pfun
 void (*pfun)(const char*) = test;
 //函数指针的数组pfunArr
 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;
 //指向函数指针数组pfunArr的指针ppfunArr
 void (*(*ppfunArr)[5])(const char*) = &pfunArr;
 return 0;
}

八. 回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个 函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

首先演示一下qsort函数的使用：

#include 
//qosrt函数的使用者得实现一个比较函数
int int_cmp(const void * p1, const void * p2)
{
  return (*( int *)p1 - *(int *) p2);
}
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int i = 0;
    
    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
   {
       printf( "%d ", arr[i]);
   }
    printf("\n");
    return 0;
}

使用回调函数，模拟实现qsort（采用冒泡的方式）。

PS：void* 是一种无类型的指针，无具体类型的指针

        void* 类型的指针变量可以存放任意类型的地址

        void* 类型的指针不能直接进行解引用操作

        void* 类型的指针不能直接进行+-整数

因为 void* 能存放任意地址，导致其灵活性也高

        如果传过来的指针是void*类型的，则需要把该类型的指针使用强制类型转换，强制转化为自己需要的类型指针，如下：

#include 
int int_cmp(const void * p1, const void * p2)
{
  return (*( int *)p1 - *(int *) p2);
}
void _swap(void *p1, void * p2, int size)
{
    int i = 0;
    for (i = 0; i< size; i++)
   {
        char tmp = *((char *)p1 + i);
       *(( char *)p1 + i) = *((char *) p2 + i);
       *(( char *)p2 + i) = tmp;
   }
}
void bubble(void *base, int count , int size, int(*cmp )(void *, void *))
{
    int i = 0;
    int j = 0;
    for (i = 0; i< count - 1; i++)
   {
       for (j = 0; j 0)
           {
               _swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);
           }
       }
   }
}
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    //char *arr[] = {"aaaa","dddd","cccc","bbbb"};
    int i = 0;
    bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
   {
       printf( "%d ", arr[i]);
   }
    printf("\n");
    return 0;
}

九. 指针和数组笔试题解析

//一维数组
int a[] = {1,2,3,4};

printf("%d\n",sizeof(a));
//计算的是整个数组元素的大小，答案16个字节

printf("%d\n",sizeof(a+0));
//不是单独放在里面，a表示的是首元素的地址，计算的是第一个元素地址的大小，答案是4/8个字节

printf("%d\n",sizeof(*a));
//a代表的是首元素的地址，*a计算的是第一个元素的大小，答案是4个字节

printf("%d\n",sizeof(a+1));
//a代表的是首元素的地址，a+1代表的是下标为2元素的地址，答案是4/8个字节

printf("%d\n",sizeof(a[1]));
//计算的下标为1元素的大小，答案是4个字节

printf("%d\n",sizeof(&a));
//&a是数组的地址，计算的是整个数组地址的大小，因为是地址的大小，所以答案是4/8个字节

printf("%d\n",sizeof(*&a));
//&a是数组的地址，它的类型是int (*)[4]的数组指针，解引用访问的是4个int类型的数组，16个字节

printf("%d\n",sizeof(&a+1));
//&a整个数组的地址+1跳过整个数组后的地址，是地址，答案是4/8个字节

printf("%d\n",sizeof(&a[0]));
//计算的是下标为0元素的地址，答案是4/8个字节

printf("%d\n",sizeof(&a[0]+1));
//计算的是下标为1的地址，答案是4/8个字节




//字符数组
char arr[] = {'a','b','c','d','e','f'};

printf("%d\n", sizeof(arr));
//计算的是整个数组的元素的大小，答案是6个字节

printf("%d\n", sizeof(arr+0));
//计算的是第一个元素地址的大小，答案是4/8个字节

printf("%d\n", sizeof(*arr));
//计算的是首元素的大小，答案是1个字节

printf("%d\n", sizeof(arr[1]));
//计算的是下标为1的元素的大小，答案是1个字节

printf("%d\n", sizeof(&arr));
//计算的是整个元素的地址的大小，答案是4/8个字节

printf("%d\n", sizeof(&arr+1));
//&a整个数组的地址+1跳过整个数组后的地址，是地址，答案是4/8个字节

printf("%d\n", sizeof(&arr[0]+1));
//计算的是下标为1的元素的地址，答案是4/8个字节




printf("%d\n", strlen(arr));
//这里arr是首元素的地址，但是计算的是数组的长度，因为没有\0，答案是随机数

printf("%d\n", strlen(arr+0));
//这里arr是首元素的地址，arr+0还是首元素地址，但是计算的是数组的长度，因为没有\0，答案是随机数

printf("%d\n", strlen(*arr));
/*strlen需要的是一个地址，从这个地址开始向后找字符，直到\0，统计字符的个数。
但是*arr是数组的首元素，也就是'a',这是传给strlen的就是'a'的ASCII码值97，
strlen函数会把97作为起始地址，统计字符串，会形成内存访问冲突*/

printf("%d\n", strlen(arr[1]));
/*strlen需要的是一个地址，从这个地址开始向后找字符，直到\0，统计字符的个数。
但是arr[1]是数组的第二个元素，也就是'b'，这是传给strlen的就是'b'的ASCII码值98，
strlen函数会把98作为起始地址，统计字符串，会形成内存访问冲突*/

printf("%d\n", strlen(&arr));
/*&arr是arr数组的地址，虽然类型和strlen的参数类型有所差异，但是传参过去后，还是从第一个字符的
位置向后数字符，答案是随机数。*/

printf("%d\n", strlen(&arr+1));
//&arr+1跳过整个数组以后的地址，开始计算长度，答案是随机数

printf("%d\n", strlen(&arr[0]+1));
//从下表为1的元素的地址开始向后数，开始计算长度，答案是随机数




char arr[] = "abcdef";

printf("%d\n", sizeof(arr));
//计算的是整个数组的大小，答案是7个字节（隐藏的\0也要算进去）

printf("%d\n", sizeof(arr+0));
//计算的是首元素地址的大小，答案是4/8个字节

printf("%d\n", sizeof(*arr));
//计算的是首元素的的大小，答案是1个字节

printf("%d\n", sizeof(arr[1]));
//计算的是下标为1的元素的大小，答案是1个字节

printf("%d\n", sizeof(&arr));
//计算的是整个数组地址的大小，答案是4/8个字节

printf("%d\n", sizeof(&arr+1));
//计算的是跳过整个数组以后的地址的大小，答案是4/8个字节

printf("%d\n", sizeof(&arr[0]+1));
//计算的是下标为1元素的地址的大小，答案是4/8个字节




printf("%d\n", strlen(arr));
//arr是首元素的地址，计算的是从首元素地址开始数的长度，答案是6

printf("%d\n", strlen(arr+0));
//arr+0是首元素的地址，计算的是从首元素地址开始数的长度，答案是6

printf("%d\n", strlen(*arr));
/*strlen需要的是一个地址，从这个地址开始向后找字符，直到\0，统计字符的个数。
但是*arr是数组的首元素，也就是'a',这是传给strlen的就是'a'的ASCII码值97，
strlen函数会把97作为起始地址，统计字符串，会形成内存访问冲突*/

printf("%d\n", strlen(arr[1]));
/*strlen需要的是一个地址，从这个地址开始向后找字符，直到\0，统计字符的个数。
但是arr[1]是数组的第二个元素，也就是'b'，这是传给strlen的就是'b'的ASCII码值98，
strlen函数会把98作为起始地址，统计字符串，会形成内存访问冲突*/

printf("%d\n", strlen(&arr));
//取出的是整个元素的地址，但是还是从首元素的地址开始数，答案是6

printf("%d\n", strlen(&arr+1));
//跳过整个数组后的地址，从该地址开始数，答案是随机数

printf("%d\n", strlen(&arr[0]+1));
//从下标为1的地址开始数，答案是5




char *p = "abcdef";
//实际上是把字符'a'的地址存进字符指针p中

printf("%d\n", sizeof(p));
//计算的是p指针变量的大小，答案是4/8个字节

printf("%d\n", sizeof(p+1));
//计算的是p+1以后的地址的大小，也就是b的地址的大小，答案是4/8个字节

printf("%d\n", sizeof(*p));
//计算的是字符'a'的大小，答案是1个字节

printf("%d\n", sizeof(p[0]));
//p[0] -> *(p+0) -> *p，计算的是字符'a'的大小，答案是1个字节

printf("%d\n", sizeof(&p));
//计算的是p的地址的大小，答案是4/8个字节

printf("%d\n", sizeof(&p+1));
//计算的是跳过一个char*以后的二级指针大小，答案是4/8个字节

printf("%d\n", sizeof(&p[0]+1));
//计算的是下标为1元素地址的大小，也就是'b'的地址，答案是4/8个字节




printf("%d\n", strlen(p));
//p中存放的是'a'的地址，strlen(p)就是从'a'的位置向后求字符串的长度，长度是6

printf("%d\n", strlen(p+1));
//p+1是'b'的地址，从b的位置开始求字符串长度是5

printf("%d\n", strlen(*p));
/* *p是字符'a'，strlen需要的是一个地址，从这个地址开始向后找字符，直到\0，统计字符的个数。
但是*p是数组的首元素，也就是'a'，这是传给strlen的就是'a'的ASCII码值97，
strlen函数会把97作为起始地址，统计字符串，会形成内存访问冲突*/

printf("%d\n", strlen(p[0]));
//p[0]->*(p+0)->*p
/* *p是字符'a'，strlen需要的是一个地址，从这个地址开始向后找字符，直到\0，统计字符的个数。
但是*p是数组的首元素，也就是'a'，这是传给strlen的就是'a'的ASCII码值97，
strlen函数会把97作为起始地址，统计字符串，会形成内存访问冲突*/

printf("%d\n", strlen(&p));
//&p相当于二级指针，从&p的地址开始数，和原字符串没关系答案是随机数

printf("%d\n", strlen(&p+1));
//&p+1相当于二级指针加一，从&p+1的地址开始数，和原字符串没关系，答案是随机数

printf("%d\n", strlen(&p[0]+1));
//p[0] -> *(p+0) -> *p ->'a' ,&p[0]就是首字符的地址，&p[0]+1就是第二个字符的地址
//也就是字符'b'的地址，从字符'b'的地址处开始数，答案是5




//二维数组
int a[3][4] = { 0 };

printf("%d\n",sizeof(a));
//计算的是整个数组的大小，答案是48个字节

printf("%d\n",sizeof(a[0][0]));
//计算的是第一个元素的大小，答案是4个字节

printf("%d\n",sizeof(a[0]));
//a[0]表示第一行的数组名，a[0]作为数组名单独放在sizeof内部
//计算的是第一行的大小，答案是16个字节

printf("%d\n",sizeof(a[0]+1));
//a[0]作为第一行的数组名，没有&，没有单独放在sizeof内部，所以a[0]表示的计算首元素的地址
//即a[0][0]的地址，a[0]+1就是第一行第二个元素的地址，答案是4/8个字节

printf("%d\n",sizeof(*(a[0]+1)));
//a[0]作为第一行的数组名，没有&，没有单独放在sizeof内部，所以a[0]表示的计算首元素的地址
//即a[0][0]的地址，a[0]+1就是第一行第二个元素的地址，解引用就是第一行第二个元素，答案是4个字节

printf("%d\n",sizeof(a+1));
//a代表首元素地址，因为是二维数组首元素地址，所以也就是第一行的地址，a+1也就是第二行的地址
//是类型为int(*)[4]的数组指针，所以答案是4/8个字节

printf("%d\n",sizeof(*(a+1)));
//a代表首元素地址，因为是二维数组首元素地址，所以也就是第一行的地址，a+1也就是第二行的地址
//是类型为int(*)[4]的数组指针，*(a+1)-》a[1]，解引用访问的是第二行元素，答案是16个字节

printf("%d\n",sizeof(&a[0]+1));
//a[0]是第一行的数组名，&a[0]是第一行的地址，&a[0]+1就是第二行的地址，答案是4/8个字节

printf("%d\n",sizeof(*(&a[0]+1)));
//a[0]是第一行的数组名，&a[0]是第一行的地址，&a[0]+1就是第二行的地址
// *(&a[0]+1)->a[1]，计算的是第二行的元素大小，答案是16个字节

printf("%d\n",sizeof(*a));
//a是二维数组的数组名，没有&，没有单独放在sizeof内部，a表示首元素地址，*a就是二维数组的首元素
// *a -> *(a+0) -> a[0]，计算的是第一行元素的大小，答案是16个字节

printf("%d\n",sizeof(a[3]));
/*a[3]虽然看起来数组越界，但是在sizeof看来，和a[0],a[1],a[2]没什么区别
因为其计算的类型的大小而前面三行的类型为 int [4] 的类型，表示一行有四个元素且类型都为int
前面三行的计算的是4个int类型的大小，所以a[3]在sizeof看来是一样的，所以答案是16个字节*/

 总结：

数组名的意义：

1. sizeof( 数组名 )，这里的数组名表示整个数组，计算的是整个数组的大小。

2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。

3. 除此之外所有的数组名都表示首元素的地址。

sizeof：

sizeof只关注占用空间的大小，单位是字节

不关注类型

是操作符

strlen：

strlen关注的字符串中中\0的为止，计算的是\0之前出现了多少个字符

针对字符串

是库函数

十. 指针笔试题

1.

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    int *ptr = (int *)(&a + 1);//跳过整个数组，落到5的后面
    printf( "%d,%d", *(a + 1), *(ptr - 1));//a代表首元素地址，ptr-1地址落到5处
    return 0;
}
//答案是 2,5

2.

//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
     int Num;
     char *pcName;
     short sDate;
     char cha[2];
     short sBa[4];
}*p;
//假设p的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
     p = (struct Test*)0x100000;
     printf("%p\n", p + 0x1);//结构体指针加一跳过一个结构体大小
     printf("%p\n", (unsigned long)p + 0x1);//long作为整形加一加上加一
     printf("%p\n", (unsigned int*)p + 0x1);//整形指针加一加上4个字节

     return 0;
}
//答案是 0x100014 0x100001 0x100004

3. 

int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int *ptr1 = (int *)(&a + 1);//跳过整个数组，指向元素4的后面
    int *ptr2 = (int *)((int)a + 1);
    printf( "%x,%x", ptr1[-1], *ptr2);
    //ptr1[-1] -> *(ptr1+(-1)) -> *(ptr-1)也就是指向元素4

    //%x打印16进制，前面的0会省略
    //%p打印地址，前面的0不省略

    return 0;
}
//答案是 4,2000000

对ptr2答案的解析：

a本来是首元素的地址，但是被强制类型转化为 int 类型相当于数值加1

假设 a 的地址为0x10，并且数据是以小端（高地址存高位，低地址存地位）的存储方式存储

则数组里数据存储方式应该是：

01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00

低地址                            ->                           高地址

则0x10的地址应该是01处，当是被强制转化为 int 以后加一，然后又强制转化 int* 的类型

此时的地址（地址一般以16进制表示）0x11指向的应该是01后面的那个00（整形类型的数据加一是跳过一个字节）

再解引用以后，应该是从01后面那个00开始往后的四个字节（ int* 指针占四个字节），开始输出，也就是从这里 00 00 00 02 开始从高地址开始以16进制输出数字，也就是 02 00 00 00，因为前面的0要省略

所以答案是 2 00 00 00

如果忘记了大小端和高低位数据的知识点，前面的 C语言进阶之深度剖析数据在内存中的存储 的博客有写，回顾！

4. 

#include 
int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    //注意有()和逗号表达式，即实际数据应该是{1 3，5 0，0 0}
    int *p;
    p = a[0];//数组名表示首元素地址，即存放的第一行第一个元素的地址
    printf( "%d", p[0]);
    return 0;
}
//答案是 1

5. 

int main()
{
    int a[5][5];
    int(*p)[4];
    p = a;
    //把a数组的第一行元素的地址给p，但是还是一样从第一个元素开始
    printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    //p[4][2] -> *(*(p+4)+2)  
    return 0;
}
//答案是 FFFFFFFC,-4

解析： 

如上图所示

首先p是一个数组指针，指向一个数组如果+1则跳过一个含4个整形的数组也就是跳过16个字节

当 a 把地址传给 p 时，还是一样从 a 的首元素地址开始

因为p[4][2] -> *(*(p+4)+2) ，所以p+4在如上图位置，解引用以后便从p+4往后开始一个字节一个字节访问（二维数组的本质，p访问的是行，p+4解引用以后再+2是开始访问列）

所以 *(*(p+4)+2)在如图的绿色方块的位置

而 a[4][2] 在图中的红色方块的位置，两者相减则是中间元素个数，因为是小地址减大地址，所以是负数

而以%p打印无非是把 -4 转成补码以后再以补码的16进制打印，这里的地址是内存中补码的16进制形式

6.

int main()
{
    int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int *ptr1 = (int *)(&aa + 1);//跳过整个数组
    int *ptr2 = (int *)(*(aa + 1));//跳过第一行数组
    printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));//10的地址，5的地址
    return 0;
}
//答案是 10,5

7.

#include 
int main()
{
     char* a[] = {"work","at","alibaba"};//指针数组分别把字符'w'，'a'，'a'的地址存放进数组
     char* *pa = a;把字符'w'的地址存放进pa
     pa++;//加一表示跳过一个 char* 的元素
     printf("%s\n", *pa);//访问的是 at 的 a 开始的字符串
     return 0;
}
//答案是 at

8.

int main()
{
     char* c[] = {"ENTER","NEW","POINT","FIRST"};
     char** cp[] = {c+3,c+2,c+1,c};
     char*** cpp = cp;
     printf("%s\n", **++cpp);
     printf("%s\n", *--*++cpp+3);
     printf("%s\n", *cpp[-2]+3);
     printf("%s\n", cpp[-1][-1]+1);
     return 0;
}
//答案是 POINT ER ST EW

 解析：

如上图

 c 数组中存放的是"ENTER","NEW","POINT","FIRST"的第一个字符的地址

cp 数组存放的 c+3,c+2,c+1,c 分别存放的是 c+3,c+2,c+1,c 的地址

而 c+3 中存放的地址可以找到字符串 "FIRST"

c+2 中存放的地址可以找到字符串 "POINT"

c+1 中存放的地址可以找到字符串 "NEW"

c 中存放的地址可以找到字符串 "ENTER"

cp 作为数组名是数组首元素地址，也就是 c+3 的地址，也就是说cpp中存放的是c+3的地址

（1）当出现 ++cpp 时，此时cpp访问的是 c+2 的地址，两次解引用以后就通过字符 'P'的地址找到了字符串 "POINT"

（2）当出现*--*++cpp+3（+的优先级在这最低），由于优先级，所以先执行++cpp（++会把本身改变），所以此时访问的是 c+1 的地址，解引用以后通过 c+1 的地址拿到了 c+1，再 -- 以后访问的是 c 的地址，解引用以后通过存放在 c 中的地址，也就是 'E' 的地址找到了字串"ENTER"，然后又 +3 ，即从下标为3的元素开始访问，也就是字符 'E'开始访问

（3）当出现*cpp[-2]+3，其中的cpp[-2] ，其实就是指针cpp -2 ，刚刚cpp指向c+1 ，然后cpp -2 以后 cpp 指向 c+3 ，解引用以后就通过 c+3 中的地址找到了字符串"FIRST"，然后又 +3 ，即从下标为3的元素，也就是字符 'S' 开始访问

（4）当出现cpp[-1][-1]+1，其中的cpp[-1][-1]其实就是 *(*(cpp-1)-1) ，也就是 cpp-1 以后访问的是 c+2 ，然后又 -1 ，此时应该是 c+2-1 ， 也就是 c+1 ，然后解引用，通过 c+1 中存放的地址找到了字符串 "NEW" 然后又 +1 ，即从下标为1的元素，也就是字符 'E' 开始访问