指针、数组练习题

指针、数组练习题

我学习过程中总结了9道比较典型的练习题。

#define _CRT_SECURE_NO_DEPRECATE 1
#include "stdio.h"

//练习1

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    int *ptr = (int*)(&a + 1);
    printf("%d,%d\n", *(a + 1), *(ptr - 1));
    return 0;
}

//程序运行结果是什么？

//分析：&a代表整个数组的地址，其偏移量为真个数组，&a+1就会跳过真个数组，是指向5后面的位置的的地址。
//    然后把这个地址强转为int*,则这个指针的偏移量变成四个字节。
//    *(a+1)中a是数组名，既没放在sizeof内，也没在&后面，那么a就是数组的首元素地址，a+1就是数组a中第
//二个元素地址，对其解引用就是第二个元素2.
//    *(ptr-1)中ptr是指向5后面的元素的指针，ptr-1就是把指针向前偏移4个字节，就会指向5，那么解引用就
//是5.

//运行结果
//2,5
//请按任意键继续. . .


//练习2

int main()
{
    struct Test 
    {
        int Num;
        char* pcName;
        short sDate;
        char cha[2];
        short sBa[4];
    }*p;
    p =0x100000;
    printf("0x%p\n", p + 0x1); 
    printf("0x%p\n", (unsigned long)p + 0x1);
    printf("0x%p\n", (unsigned int*)p+0x1);
    return 0;
}

//假设p的值为0x100000。下面表达式的值分别是多少？
//p+0x1=0x__________?
//(unsigned long)p+0x1=0x____________?
//(unsigned int*)p+0x1=0x____________?

//分析：p+0x1是把指针p向后偏移0x1=1,而p是结构体的指针，他的偏移量是结构体的大小，计算可知是20个字节。
//      那么p的地址增加20，而由于地址用16进制表示，所以p增加0x14,即0x100014.
//      (unsigned long)p + 0x1  把p指针强转成unsigned long类型，p就不再是指针了，变成了变量，所以p+1
//就单纯加了个1，即0x100001.
//       强转成unsigned int*，指针p的偏移量就变成4，p+1则地址加4，即0x100004.

//运行结果
//0x00100014
//0x00100001
//0x00100004
//请按任意键继续. . .


//练习3

int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int *ptr1 = (int*)(&a + 1);
    int *ptr2 = (int *)((int)a + 1);
    printf("%x,%x", ptr1[-1], *ptr2);
    return 0;
}

//分析：*ptr1 = (int*)(&a + 1):&a是数组a的地址，&a+1则表示表示跳过数组a指向数组的后面的元素的地址，对其强转
//   为int*则代表其偏移量有一个数组变成了4个字节。ptr1[-1]:代表对ptr1指针先向左偏移一个偏移量，再解引用。 
//   偏移后指针指向数组a中元素4，解引用就是4。
//      *ptr2 = (int *)((int)a + 1）：在这里a代表数组的首元素地址，把其强转为整形，然后加一，就是给1的地址加一
//   个字节，a在内存中的存放为01 00 00 00 02 00 00 00 00 03 00 00 00 04 00 00 00.那现在就指向01后面的00 00 00 
//   02 ，由于是小端存储，所以解引用取出来后就是02 00 00 00，即2000000。

//运行结果：
//4,2000000请按任意键继续. . .



//练习4


int main(int argc,char* argv[])
{
    int a[3][2] = { (0, 1), (1, 2), (4, 5) };
    int *p;
    p = a[0];
    printf("%d", p[0]);
    return 0;
}


//分析：这个题是个坑，得仔细分析。首先数组a是个二维数组，但是明显对其赋值有问题，二维数组赋值是这样的：a[3][2]
//      ={{0,1},{1,2},{4,5}}.所以很明显题目中的赋值不是整个数组，而是只有三个元素，分别是第0行两个和第一行1个，而（）
//      则是逗号表达式，简化为a[3][2]={1,2,5}.把a[0]赋给p，就是让指针p指向数组a的第0行，则p实际指向第0行首元素，p[0]
//      表示偏移0再解引用，即第0行的首元素1.

//运行结果：
//1请按任意键继续. . .



//练习5

int main()
{
    int a[5][5];
    int(*p)[4];
    p = a;
    printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    return 0;
}


//分析：【】【】【】【】【】 【】【】【】【】【】 【】【】【】【】【】 【】【】【】【】【】 【】【】【】【】【】
// 代表a[5][5].p是指针数组，p=a，代表p数组存储的四个指针指向数组a的0—3行，则数组p的情况可以表示为：
//【】【】【】【】【】 【】【】【】【】【】 【】【】【】【】【】 【】【】【】【】【】
//&p[4][2]-&a[4][2]代表第19个元素的地址减去第23个元素的地址等于-4.
//%d的形式打印则是-4.
//%p则是以地址的形式打印-4，整形-4的二进制：
//10000000 00000000 00000000 00000100   源码
//11111111 11111111 11111111 11111011   反码
//11111111 11111111 11111111 11111100   补码
//-4是个负数，在内存中存放其补码，但以%p打印时，是将其当作地址，是无符号数，即是正数，那他的源码就是补码。
//即
//11111111 11111111 11111111 11111100
//FF       FF       FF       F   C

//运行结果：
//FFFFFFFC,-4
//请按任意键继续. . .



//练习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));
    return 0;
}



//分析：*ptr1 = (int *)(&aa + 1)：&aa表示数组aa的地址，&aa+1则表示跳过aa这个数组指向数组后面的元素的地址。
//      对其强转为int*，则把其偏移量由一个数组改为一个整形4个字节。*(ptr1 - 1)表示ptr指针向前偏移一个偏移量，
//      然后解引用。则结果就是10.
//      *ptr2 = (int *)(*(aa + 1))：aa+1表示数组aa[5][2]的首行地址加一，即指向aa[1]的地址。 *（aa+1）表示
//      aa[1][0]的地址，对其强转为int*赋给ptr1，表示ptr的偏移量为int，4个字节。*(ptr2 - 1)表示ptr指针向前
//      偏移一个偏移量，然后解引用，即aa[1][0]的前一个元素5.


//运行结果：
//10,5请按任意键继续. . .




//练习7


//解释下面的代码、
(* (void(*) ( )) 0 )( );
//1.把0强转为一个函数指针，该函数指针所指向的函数的返回类型为void，无参数。
//2.对函数指针解引用相当于函数名，所以这是个函数声明。
void(*signal(int, void(*)(int)))(int);
//1.signal是一次函数声明。
//2.signal函数的第一个参数是int，第二个参数是函数指针，该函数指针指向的函数参数为int，返回类型为
//  void。
//3.signal函数的返回类型为一个函数指针，该函数指针指向的函数的参数为int，返回类型为void。



//练习8


int main()
{
    char *a[] = { "work", "at", "alibaba" };
    char **pa = a;
    pa++;
    printf("%s\n", *pa);
    return 0;
}

//分析：
//a是一个指针数组，他的三个元素分别是指向三个字符串的指针，假如为char *p1，p2，p3，
//把a的首地址赋给二级指针pa，则pa指向p1.pa++后，pa指向p2，*pa则取出p2的内容“at”。


//运行结果：
//at
//请按任意键继续. . .



//练习9


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

//分析：c是指针数组，他的元素是四个指针，假如为p1,p2,p3,p4.分别指向四个字符串，也就是指向首元素。
//      cp是二级指针数组，元素是二级指针，假如为cp1,cp2'cp3,cp4.而cp1->p4,cp2->p3,cp3->p2,cp4->
//      p1.cpp是个三级指针，cpp->cp1.
//      1.**++cpp:++cpp,cpp->cp2.解引用*++cpp,cp2->p3.再解引用**++cpp,p3->"POINT".
//      2.*--*++cpp+3：++cpp,cpp->cp3.解引用*++cpp,cp3->p2.--*++cpp,cp3->p1.再解引用
//      *--*++cpp,p1->"ENTER".*--*++cpp+3,p1+3->"ER".
//      3.*cpp[-2]+3:cpp[-2],cpp先-2再解引用，cpp->cp1,cp1->p4.解引用*cpp[-2],p4->"FIRST".*cpp[-2]+3,
//       p4+3->"ST"但cpp本身没有变cpp->cp3.
//      4.cpp[-1][-1]+1:cpp[-1],cpp先-1，cpp->cp2,再解引用找到cp2->p3.cpp[-1][-1],cp2先-1，cp2->p2
//         再解引用找到p2->"NEW".p2+1->"EW".但cpp和cp2本身没变，cpp->cp3,cp2->p3.

//运行结果：
//POINT
//ER
//ST
//EW
//请按任意键继续. . .