C语言指针重点总结(5)

1. sizeof和strlen的对比

1.1 sizeof

sizeof不是函数,而是一个操作符,sizeof 计算变量所占内存内存空间大小的,单位是字节,如果操作数是类型的话,计算的是使用类型创建的变量所占内存空间的大小。 sizeof 只关注占⽤内存空间的大小,不在乎内存中存放什么数据。

sizeof()的操作数可以是一个变量也可以是一个数据类型,需要注意的是当操作数是变量时()可以省去,当操作数是数据类型时()不可以省去。

#inculde 
int main()
{
     int a = 10;
     printf("%d\n", sizeof(a));
     printf("%d\n", sizeof a);
     printf("%d\n", sizeof(int));
 
     return 0;
}

1.2 strlen

1.2.1 strlen函数简介

strlen 是C语⾔库函数,使用时要包含头文件string.h,功能是求字符串长度。函数原型如下: 

size_t strlen ( const char * str );  返回值size_t类型实质上就是无符号整型,打印时的形式的zd%,参数是一个字符指针,const修饰的是*str,使得不能通过指针改变原字符串的内容。本质是从该字符指针指向的位置/字符开始计数,直到遇到\0(\0的ASCII码是0),停止计数,返回字符不是\0的个数,strlen要遇到\0才停止计算,故strlen可能出现越界查找的问题。

1.2.2 strlen函数的模拟实现

size_t my_strlen(const char* p)
{
    int count = 0;
    while(*p) //*p != '\0'
    {
       count++;
       p++;
    }
    return count;
}

1.2.3 strlen函数使用示例

#include 
int main()
{
     char arr1[3] = {'a', 'b', 'c'};
     char arr2[] = "abc";
     printf("%zd\n", strlen(arr1));//随机数
     printf("%zd\n", strlen(arr2));//3
 
     printf("%zd\n", sizeof(arr1));//3
     printf("%zd\n", sizeof(arr1));//4
     return 0;
}

1.3 sizeof 和 strlen的对比

C语言指针重点总结(5)_第1张图片

C语言指针重点总结(5)_第2张图片

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

数组名的意义

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

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

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

2.1 ⼀维数组 

    int a[] = {1,2,3,4};
    printf("%d\n",sizeof(a));      //4*4=16 szieof(数组名)特殊用法表示求整个数组的大小
    printf("%d\n",sizeof(a+0));    //4/8 数组名a表示首元素地址,即元素1的地址
    printf("%d\n",sizeof(*a));     //4 *a == *(a+0) == a[0] == 1
    printf("%d\n",sizeof(a+1));    //4/8 数组名a表示首元素地址,a+1是a[1]的地址
    printf("%d\n",sizeof(a[1]));   //4 a[1] == 2
    printf("%d\n",sizeof(&a));     //4/8 &数组名,表示整个数组的地址
    printf("%d\n",sizeof(*&a));    //16 1.*和&可以相互抵消,sizeof(*&a) == sizeof(a)
                                   //2.&数组名,表示整个数组的地址,解引用后就是整个数组
    printf("%d\n",sizeof(&a+1));   //4/8 &数组名,表示整个数组的地址,&a+1跳过整个数组        
    printf("%d\n",sizeof(&a[0]));  //4/8 数组第一个元素的地址
    printf("%d\n",sizeof(&a[0]+1));//4/8 数组第二个元素的地址
    
    

C语言指针重点总结(5)_第3张图片

注意点:
地址是4/8个字节的原因,地址长度由当前系统决定,当编译器选择32位机(x86),数据的地址有32位,32/8(一个字节的位数)=4(Byte)。当编译器选择64位机(x64),数据的地址有64位,64/8(一个字节的位数)=8(Byte)

注意不要混淆

32位机的%p打印出来地址是0000 00ff:%p是以16进制打印地址的,32/4(二进制转十六进制1111=f)=8位,64位机的%p打印出来地址是0000 0000 0000 00ff:64/4(二进制转十六进制1111=f)=16位

2.2 字符数组

代码1

char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));           //6 sizeof(数组名),计算整个数组的大小
printf("%d\n", sizeof(arr+0));         //4/8 数组名arr表首元素地址,arr+0还是首元素的地址
printf("%d\n", sizeof(*arr));          //1 数组名arr表首元素地址,*arr == 'a'
printf("%d\n", sizeof(arr[1]));        //1 arr[1] == 'b'
printf("%d\n", sizeof(&arr));          //4/8 &arr表示整个数组的地址
printf("%d\n", sizeof(&arr+1));        //4/8 &arr+1表示跳过整个字符数组
printf("%d\n", sizeof(&arr[0]+1));     //4/8 &arr[0]+1表示&arr[1]即符号'b'的地址

C语言指针重点总结(5)_第4张图片

代码2

    char arr[] = {'a','b','c','d','e','f'};
    printf("%d\n", strlen(arr));       //随机值 数组名arr表示首元素地址,直到遇到\0停止计数
    printf("%d\n", strlen(arr+0));     //随机值 数组名arr表示首元素地址,arr+0还是首元素地址
    printf("%d\n", strlen(*arr));      //err *arr == 'a','a'的ASCII码是97,取的地址是97
    printf("%d\n", strlen(arr[1]));    //err arr[1] == 'b','b'的ASCII码是98,取的地址是98
    printf("%d\n", strlen(&arr));      //随机值 strlen函数的参数类型是char*,而&arr表示整个数 
                                       //组的地址,指针类型是char(*)[6],是一个数组的指针,所以  
                                       //会报警告但不会报err,结果与strlen(arr)的结果保持一致
    printf("%d\n", strlen(&arr+1));    //随机值-6 &arr+1跳过整个数组的大小
    printf("%d\n", strlen(&arr[0]+1)); //随机值-1 &arr[0]+1表示'b'的地址

C语言指针重点总结(5)_第5张图片

C语言指针重点总结(5)_第6张图片 代码3

    char arr[] = "abcdef"; //等价于char arr[] = {'a','b','c','d','e','f','\0'};
    printf("%d\n", sizeof(arr));      //7 sizeof(数组名)特殊用法求整个数组的大小
    printf("%d\n", sizeof(arr+0));    //4/8 数组名arr表示首元素地址,arr+0仍表示首元素地址
    printf("%d\n", sizeof(*arr));     //1 *arr == 'a'
    printf("%d\n", sizeof(arr[1]));   //1 arr[1] == 'b'
    printf("%d\n", sizeof(&arr));     //4/8 &arr表示整个数组的大小
    printf("%d\n", sizeof(&arr+1));   //4/8 &arr+1表示跳过整个数组的大小
    printf("%d\n", sizeof(&arr[0]+1));//4/8 &arr[0]+1 == &arr[1],字符'b'的地址

C语言指针重点总结(5)_第7张图片 代码4 

    char arr[] = "abcdef";
    printf("%d\n", strlen(arr));     //6 数组名arr表示首元素的地址
    printf("%d\n", strlen(arr+0));   //6 arr+0仍表示首元素的地址
    printf("%d\n", strlen(*arr));    //err *arr == 'a' ASCII码表示97
    printf("%d\n", strlen(arr[1]));  //err arr[1] == 'b' ASCII码表示98  
    printf("%d\n", strlen(&arr));    //6 &arr表示整个数组的地址
    printf("%d\n", strlen(&arr+1));  //随机值 &arr+1跳过整个数组
    printf("%d\n", strlen(&arr[0]+1));//5  &arr[0]+1 ==&arr[1]

C语言指针重点总结(5)_第8张图片 C语言指针重点总结(5)_第9张图片

C语言指针重点总结(5)_第10张图片 代码5

    char *p = "abcdef";         
    printf("%d\n", sizeof(p));     //4/8 p是指向字符串第一个字符a的指针
    printf("%d\n", sizeof(p+1));   //4/8 p+1指向字符串第二个字符b的指针
    printf("%d\n", sizeof(*p));    //1 *p == 'a',表示一个字符
    printf("%d\n", sizeof(p[0]));  //1 p[0] == *(p+0) == 'a'
    printf("%d\n", sizeof(&p));    //4/8 &p表示指针的地址,是二级指针,类型是char* *:第二个*表 
                                   //示是一个指针,第二个*表示该指针指向对象的类型是char*,即+-
                                   //该指针时跳过的是一个char*类型(地址,4/8个字节) 
    printf("%d\n", sizeof(&p+1));  //4/8
    printf("%d\n", sizeof(&p[0]+1));//4/8 &p[0]+1 == &p[1]即字符'b'的地址

C语言指针重点总结(5)_第11张图片C语言指针重点总结(5)_第12张图片跳过一个char*变量,char*是一个指向char类型的指针/地址,大小是4/8个字节,则跳过一个char*变量就是跳过4/8个字节。

 代码6

    char *p = "abcdef";
    printf("%d\n", strlen(p));       //6 指针p指向字符'a'
    printf("%d\n", strlen(p+1));     //5 指针p+1指向字符'b'
    printf("%d\n", strlen(*p));      //err *p == 'a',ASCII码值是97
    printf("%d\n", strlen(p[0]));    //err p[0] == *p == 'a',ASCII码值是97
    printf("%d\n", strlen(&p));      //随机值 指针p的地址,二级指针
    printf("%d\n", strlen(&p+1));    //随机值 &p+1跳过一个char*类型
    printf("%d\n", strlen(&p[0]+1)); //5 &p[0]+1 == &p[1]即字符'b'的地址

最后一个strlen(&p[0]+1) ,指针p优先与[]结合,p[0] == *p == 'a' ,再与&结合,表示第一个元素的地址,+1表示第二个元素的地址,下面详见操作符的优先级。

C语言指针重点总结(5)_第13张图片
 C语言指针重点总结(5)_第14张图片

C语言指针重点总结(5)_第15张图片

2.3 ⼆维数组

    int a[3][4] = {0};
    printf("%d\n",sizeof(a));        //3*4*4=48 sizeof(数组名),计算整个二维数组的有多少个字节
    printf("%d\n",sizeof(a[0][0]));  //4 a[0][0]表示整个数组的第一个元素
    printf("%d\n",sizeof(a[0]));     //4*4=16 a[0]表示二维数组第1行的数组名,sizeof(数组名)特 
                                     //殊用法,表达整个数组的大小
    printf("%d\n",sizeof(a[0]+1));   //4/8 数组名a[0]表示数组首元素的地址,即&a[0][0],+1是
                                     //a[0][1]的地址即&a[0][1]
    printf("%d\n",sizeof(*(a[0]+1)));//4 等价于*&a[0][1] == a[0][1] == 0
    printf("%d\n",sizeof(a+1));      //4/8 二维数组数组名a表示首元素地址,二维数组的首元素是第 
                                     //一行,故a+1 == &a[0]+1,表示第二行的地址即&a[1]
    printf("%d\n",sizeof(*(a+1)));   //4*4=16 等价于*&a[1] == a[1],求第二行的总字节数 
    printf("%d\n",sizeof(&a[0]+1));  //4/8 表示第二行的地址即&a[1]
    printf("%d\n",sizeof(*(&a[0]+1)));//4*4=16 等价于*&a[1] == a[1],求第二行的总字节数
    printf("%d\n",sizeof(*a));        //4*4=16 二维数组数组名a表示首元素地址,二维数组的首元素
                                      //是第一行,故*a == *&a[0] == a[0],求第一行的总字节数
    printf("%d\n",sizeof(a[3]));      //4*4=16 不会报错,sizeof()只是求()里的变量类型有多少个
                                      //字节,本质相当于求sizeof(a[0]),即求一行的字节个数

C语言指针重点总结(5)_第16张图片

C语言指针重点总结(5)_第17张图片

3. 指针运算笔试题解析

3.1 题目1

#include 
int main()
{
 int a[5] = { 1, 2, 3, 4, 5 };
 int *ptr = (int *)(&a + 1);
 printf( "%d,%d", *(a + 1), *(ptr - 1));
 return 0;
}
//程序的结果是什么?2 5

C语言指针重点总结(5)_第18张图片

3.2 题目2

//在X86环境下
//假设结构体的⼤⼩是20个字节
//程序输出的结构是啥?
struct Test
{
    int Num;
    char *pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}*p = (struct Test*)0x100000;
int main()
{
    printf("%p\n", p + 0x1);
    printf("%p\n", (unsigned long)p + 0x1);//注意这里指针p强转为了为符号长整型,相当于转换成了 
                                           //地址(相当于0000 00ff),+1就是普通的整数+1
    printf("%p\n", (unsigned int*)p + 0x1);
    return 0;
}

假设的原因是x64环境下结构体的大小就不是20个字节了 

C语言指针重点总结(5)_第19张图片

C语言指针重点总结(5)_第20张图片

C语言指针重点总结(5)_第21张图片

C语言指针重点总结(5)_第22张图片

3.3 题目3

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

注意点:逗号表达式,从左向右依次执⾏。整个表达式的结果是最后⼀个表达式的结果。 

C语言指针重点总结(5)_第23张图片

3.4 题目4

//假设环境是x86环境,程序输出的结果是啥?
#include 
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;
} //答案:FFFF FFFC   4

 限制环境是因为想要一个唯一的答案,32位和64位的地址长度不同。

C语言指针重点总结(5)_第24张图片

C语言指针重点总结(5)_第25张图片

3.5 题目5

#include 
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;
}
详解:int *ptr2 = (int *)(*(aa + 1));
二维数组数组名aa表首元素的地址,二维数组的首元素是第一行,则aa是第一行的地址,aa+1是第二行的地址及&aa[1],*(aa+1) == *&aa[1] == aa[1](第二行的数组名),数组名aa[1]表示首元素aa[1][0]的地址.*(aa + 1)本身就是int*类型,这里的强转如同虚设。

C语言指针重点总结(5)_第26张图片

3.6 题目6

#include 
int main()
{
    char *a[] = {"work","at","alibaba"};//[]的优先级比*高,故a先与[]结合,a是一个指针数组,指 
                                        //针类型是char*
    char**pa = a;                       //两级指针,数组名a表示首元素的地址,pa指向a[0]
    pa++;                               //pa指向a[1]
    printf("%s\n", *pa);                //*pa == a[1] == 指向字符'a'的char*指针
    return 0;
}
//答案:at

C语言指针重点总结(5)_第27张图片3.7 题目7

 

#include 
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语言指针重点总结(5)_第28张图片C语言指针重点总结(5)_第29张图片

 C语言指针重点总结(5)_第30张图片

你可能感兴趣的:(C语言,c语言,算法,开发语言)