【C语言进阶】指针(sizeof和strlen的使用)

最新推荐文章于 2024-06-25 21:05:21 发布
最新推荐文章于 2024-06-25 21:05:21 发布
阅读量2k 收藏 22
点赞数 6
文章标签： c语言 c++ 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/awww224112/article/details/128621486
版权

一、sizeof和strlen简介

[1]sizeof介绍

sizeof计算数据内存空间大小，是一种操作符

具有类型属性，只关注数据的类型，()内的表达式不进行运算

在数组中数组名arr只在两种情况下表示整个数组：

1.sizeof(数组名)中数组名表示整个数组

2.&数组名表示取出整个数组的地址

其余情况下数组名arr都表示首元素地址

[2]strlen介绍

size_t strlen(const char* str)

size_t-->unsigned int表示无符号整形

strlen是计算字符串长度的库函数，遇到'\0'时停止，计算的是'\0'之前的字符数目。

二、sizeof和strlen运用

    • 一维数组中的运用

int main()
{
    //一维数组
    int a[] = { 1,2,3,4 };//4*4=16
    printf("%d\n", sizeof(a));//16
    printf("%d\n", sizeof(a + 0));//a+0 其实是数组第一个元素的地址，是地址就是4/8字节
    printf("%d\n", sizeof(*a));//*a是数组首元素，计算的是数组首元素的大小，单位是字节，4
    printf("%d\n", sizeof(a + 1));//a+1是第二个元素的地址，是地址大小就是4/8
    printf("%d\n", sizeof(a[1]));//a[1]是第二个元素，计算的是第二个元素的大小-4-单位是字节
    printf("%d\n", sizeof(&a));//&a是整个数组的地址，整个数组的地址也是地址，地址的大小就是4/8字节
    //&a---> 类型：int(*)[4]

    printf("%d\n", sizeof(*&a));//&a是数组的地址，*&a就是拿到了数组，*&a--> a,a就是数组名，sizeof(*&a)-->sizeof(a)
    //计算的是整个数组的大小，单位是字节-16

    printf("%d\n", sizeof(&a + 1));//&a是整个数组的地址，&a+1，跳过整个数组，指向数组后边的空间，是一个地址，大小是4/8字节
    printf("%d\n", sizeof(&a[0]));//&a[0]是首元素的地址，计算的是首元素地址的大小，4/8字节
    printf("%d\n", sizeof(&a[0] + 1));//&a[0] + 1是第二个元素的地址，地址的大小就是4/8字节
    return 0;
}

2.字符数组中的运用

int main()
{
    //字符数组
    char arr[] = { 'a','b','c','d','e','f' };
    //char*
    //char [6]
    printf("%d\n", strlen(arr));//'\0'的位置不确定，因此为随机值
    printf("%d\n", strlen(arr + 0));//'\0'位置不确定也是随机值
    printf("%d\n", strlen(*arr));//strlen('a')->strlen(97),非法访问-error，会出现问题
    printf("%d\n", strlen(arr[1]));//'b'-98,和上面的代码类似，是非法访问 - error，会出现问题
    printf("%d\n", strlen(&arr));//&arr虽然是数组的地址，但是也是从数组起始位置开始的，计算的还是随机值
    //char(*)[6]
    printf("%d\n", strlen(&arr + 1));
    //&arr是数组的地址，&arr+1是跳过整个数组的地址，求字符串长度也是随机值
    printf("%d\n", strlen(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址，是'b'的地址，求字符串长度也是随机值

    //printf("%d\n", sizeof(arr));//arr单独放在sizeof内部，计算的是整个数组的大小，单位是字节，6
    //printf("%d\n", sizeof(arr + 0));//arr + 0是数组首元素的地址，4/8
    //printf("%d\n", sizeof(*arr));//*arr是数组的首元素，计算的是首元素的大小-1字节
    //printf("%d\n", sizeof(arr[1]));//arr[1]是第二个元素，大小1字节
    //printf("%d\n", sizeof(&arr));//取出的数组的地址，数组的地址也是地址，是地址大小就是4/8
    //printf("%d\n", sizeof(&arr + 1));//&arr+1是跳过整个，指向数组后边空间的地址，4/8
    //printf("%d\n", sizeof(&arr[0] + 1));//&arr[0] + 1是数组第二个元素的地址，是地址4/8字节
    return 0;
}
int main()
{
    char arr[] = "abcdef";//数组是7个元素
    //[a b c d e f \0]
    printf("%d\n", strlen(arr));//6,arr是数组首元素的地址，strlen从首元素的地址开始统计\0之前出现的字符个数，是6
    printf("%d\n", strlen(arr + 0));//arr + 0是数组首元素的地址，同第一个，结果是6
    printf("%d\n", strlen(*arr));//*arr是'a',是97，传给strlen是一个非法的地址，造成非法访问-error
    printf("%d\n", strlen(arr[1]));//与上述情况相同，非法访问-error
    printf("%d\n", strlen(&arr));//取出的是整个数组的地址，实际存储的数据和首元素地址一致，大小为6
    printf("%d\n", strlen(&arr + 1));//&arr + 1是跳过数组后的地址，统计字符串的长度是随机值
    printf("%d\n", strlen(&arr[0] + 1));//&arr[0]+1是b的地址，从第二个字符往后统计字符串的长度，大小是随机值

    printf("%d\n", sizeof(arr));//数组名单独放在sizeof内部，计算的是数组的总大小，为6字节
    printf("%d\n", sizeof(arr + 0));//arr+0是首元素的地址，大小是4/8
    printf("%d\n", sizeof(*arr));//*arr是数组首元素，大小是1字节
    printf("%d\n", sizeof(arr[1]));//arr[1]是数组的第二个元素，大小是1字节
    printf("%d\n", sizeof(&arr));//&arr是数组的地址，数组的地址也是地址，是4/8字节
    printf("%d\n", sizeof(&arr + 1));//&arr + 1是跳过整个数组的地址，是4/8字节
    printf("%d\n", sizeof(&arr[0] + 1));//&arr[0] + 1是第二个元素的地址，是4/8字节

    return 0;
}

3.指针中的运用

//int main()
//{
//    const char* p = "abcdef";
//    //存的是a的地址
//    printf("%d\n", strlen(p));//p存放的是a的地址，求字符串长度就是6
//    printf("%d\n", strlen(p + 1));//p + 1是b的地址，求字符串长度就是5
//    //printf("%d\n", strlen(*p));//error，*p是'a',非法访问
//    //printf("%d\n", strlen(p[0]));//error - 同上一个
//    printf("%d\n", strlen(&p));//&p拿到的是p这个指针变量的起始地址，从这里开始求字符串长度完全是随机值
//    printf("%d\n", strlen(&p + 1));//&p+1是跳过p变量的地址，从这里开始求字符串长度也是随机值
//    printf("%d\n", strlen(&p[0] + 1));//&p[0] + 1是b的地址，从b的地址向后数字符串的长度是5
//
//    //printf("%d\n", sizeof(p));//p是指针变量，大小就是4/8字节
//    //printf("%d\n", sizeof(p + 1));//p + 1是b的地址，是地址，就是4/8个字节
//    //printf("%d\n", sizeof(*p));//*p是'a'，sizeof(*p)计算的是字符的大小，是1字节
//    //printf("%d\n", sizeof(p[0]));//p[0]-->*(p+0) --> *p  就同上一个，1字节
//    //printf("%d\n", sizeof(&p));//&p是二级指针，是指针大小就是4/8
//    //printf("%d\n", sizeof(&p + 1)); //&p + 1是跳过p变量后的地址，4/8字节
//    //printf("%d\n", sizeof(&p[0] + 1));//p[0]就是‘a’,&p[0]就是a的地址，+1，就是b的地址，是地址就是4/8
//
//    return 0;
//}

4.二维数组中的运用

//int main()
//{
//    int a[3][4] = { 0 };
//    //printf("%p\n", &a[0][0]);//取出第一行第一个元素的地址
//    //printf("%p\n", a[0]+1);//a[0]表示第一行数组名，a[0]+1表示第一行第二个元素地址
//    printf("%d\n", sizeof(a));//数组名表示整个数组，大小为3*4*4=48字节
//    printf("%d\n", sizeof(a[0][0]));//第一行第一个元素，计算元素大小，为4字节
//    printf("%d\n", sizeof(a[0]));//a[0]是第一行的数组名，数组名单独放在sizeof内部，计算的就是数组(第一行)的大小，16个字节
//    printf("%d\n", sizeof(a[0] + 1));//a[0]作为第一行的数组名，没有单独放在sizeof内部，没有取地址，表示的就是数组首元素的地址
//    //那就是a[0][0]的地址，a[0]+1就是第一行第二个元素的地址，是地址就是4/8个字节
//    printf("%d\n", sizeof(*(a[0] + 1)));//*(a[0] + 1)是第一行第2个元素，计算的是元素的大小-4个字节
//    printf("%d\n", sizeof(a + 1));//a是二维数组的数组名，数组名表示首元素的地址，就是第一行的地址，a+1就是第二行的地址
//    //第二行的地址也是地址，是地址就是4/8   
//    //a - int (*)[4]
//    //a+1--> int(*)[4]
//    printf("%d\n", sizeof(*(a + 1)));//a+1是第二行的地址，*(a+1)表示的就是第二行，*(a+1)--a[1]  //16
//    printf("%d\n", sizeof(&a[0] + 1));//&a[0]是第一行的地址，&a[0]+1是第二行的地址，地址的大小就是4/8
//    printf("%d\n", sizeof(*(&a[0] + 1)));//*(&a[0] + 1) 是对第二行的地址解引用，得到的就是第二行，计算的就是第二行的大小
//    printf("%d\n", sizeof(*a));//a表示首元素的地址，就是第一行的地址，*a就是第一行，计算的就是第一行的大小
//    //*a -- *(a+0)--a[0]
//    printf("%d\n", sizeof(a[3]));//16字节 int[4]
//    //如果数组存在第四行，a[3]就是第四行的数组名，数组名单独放在sizeof内部，计算的是第四行的大小
//
//    return 0;
//}

在C语言中表达式有两种属性：

1.值属性

    • 类型属性

//int main()
//{
//    short s = 3;
//    int a = 10;
//    s = a + 2;
//    //运算后发生截断
//    printf("%d\n", sizeof(s = a + 2));//2
//    //sizeof在操作时并不会计算（）中的表达式，只关心是什么类型的数据
//    //s为short型，因此计算结果为2
//    printf("%d\n", s);
//    //而单独运算s%d打印时发生整形提升，打印最终结果
//    return 0;
//}

sizeof在编译阶段就执行完毕，而表达式的运算需要在运行的时候开始执行，所以其内部不会发生表达式的运算，只关心（）内部表达式的类型，具有类型属性

二、指针练习题

1.

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

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);
//    //0x00100014
//    //结构体类指针+1跳过一个结构体，在原有地址基础上+20
//    printf("%p\n", (unsigned long)p + 0x1);
//    //0x00100001
//    //整形家族数据+1表示的就是在原有数据基础上+1（比如3+1-->4）
//    printf("%p\n", (unsigned int*)p + 0x1);
//    //0x00100004
//    //无符号整形指针+1跳过一个unsigned int类型数据，在原有数据基础上+4
//    return 0;
//}

强制类型转换是先将十六进制的地址转换为二进制，在发生截断并加上相应的值

3.

//小端，x86环境
//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);//0x00000004 0x02000000
//    return 0;
//}

4.

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

逗号表达式运算顺序是从左至右，最后一个数据是最终结果。

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

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

7.

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

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);//POINT
//    printf("%s\n", *-- * ++cpp + 3);//ER
//    printf("%s\n", *cpp[-2] + 3);//ST
//    printf("%s\n", cpp[-1][-1] + 1);//EW
//
//    return 0;
//}

伱恏呀呀呀呀
关注
  • 6
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++ sizeof 使用规则及陷阱分析
天下无双
02-21 1354
C++ sizeof 使用规则及陷阱分析2006-09-07 06:00作者：出处：blog责任编辑：方舟　　1、什么是sizeof 　　首先看一下sizeof在msdn上的定义： 　　The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a
每日一c，.用strlen()，sizeof() 及空指针的梳理（三）
Mr.Wang的博客
06-05 1852
时间：2017/06/05 11:30 一.用strlen()求字符串的长度及与sizeof（）的区别 库函数strlen的原型为：size_t  strlen( char const *string ); strlen返回一个类型为size_t的值。这个类型是在头文件stddef.h中定义的，它是一个无符号整型类型。 在表达式中使用无符号数可能导致不可预期的结果。例如，下面两个表
有关strlen和sizeof的归纳与总结
03-07
都是在网上下载资料，然后自己整理而成。详细的介绍了strlen和sizeof的区别和用法，这在应用程序是，有很高的帮助。
C语言sizeof与strlen详解
最新发布
2302_81312180的博客
06-25 469
sizeof 计算的，单位是字节，如果操作数是类型的话，计算的是使用类型创建的变量所占内存空间的大小。sizeof 只关注占用内存空间的大小，不在乎内存中存放什么数据。strlen 是C语言库函数，功能是求字符串长度。统计的是从 strlen 函数的参数 str 中这个地址开始向后，。strlen 函数会一直向后找 \0 字符，直到找到为止，所以可能存在越界查找。1. sizeof是操作符。2. sizeof计算操作数所占内存的大小，单位是字节。3. 不关注内存中存放什么数据。
sizeof(数组名)和sizeof(指针)
热门推荐
KangRoger的专栏
03-06 14万+
在做这道题时： 32位环境下，int *p=new int[10];请问sizeof(p)的值为（） A、4              B、10              C、40               D、8 我以为正确答案为C，int类型为32位，占四个字节，10个自然就是40了，结果正确答案为A，只是指针p占的空间。 因此写段代码测试一下： #include using
指针的大小--sizeof问题
蛋疼先生的手札
05-30 780
指针的大小是问：一个指针变量占用多少内存空间？ 分析：既然指针只是要存储另一个变量的地址，。注意，是存放一变量的地址，而不是存放一个变量本身，所以，不管指针指向什么类型的变量，它的大小总是固定的：只要能放得下一个地址就行！（这是一间只有烟盒大小的“房间”，因为它只需要入一张与着地址的纸条）。 存放一个地址需要几个字节？答案是和一个 int 类型的大小相同：4字节。 所以,若有： ...
C语言——sizeof与strlen用法
qq_59599094的博客
09-10 3758
C语言——sizeof与strlen（）函数的用法与区别，详细
sizeof&指针
月球人的专栏
06-10 997
// sizeof.cpp : Defines the entry point for the console application. // #include "StdAfx.h" #include "iostream.h" int main(int argc, char* argv[]) { // int **a[3][4]; // cout // return 0;  //
C指针之指针、数组与sizeof运算符
baidu_41388533的博客
06-14 787
指针、数组与sizeof运算符 sizeof是C语言的一个运算符 主要sizeof不是函数，虽然用法很像函数，sizeof的作用是用来返回()里面的变量或者数据类型占用的内存字节数。 sizeof存在的价值 主要是因为在不同平台下各种数据类型所占的内存字节数不尽相同（譬如int在32位系统中为4字节，在16位系统中为2字节···）。 所以程序中需要使用sizeof来判断当前变量/数据类型在当前环境下占几个字节。 char str[] = ”hello”; sizeof(str)...
深刻了解C语言中的sizeof()和strlen()
qq_61784009的博客
10-19 1147
sizeof和strlen在C语言中的区别
C语言中关于sizeof 和 strlen的区别分析
09-03
在C语言中，`sizeof`和`strlen`是两个非常重要的操作符，它们分别用于获取内存占用大小和字符串长度。虽然两者看似相似，但其实有着本质的区别，这主要体现在它们的计算时机、适用对象和计算内容上。 1. **编译时...
C语言中的sizeof操作符用法及和strlen的区别
09-03
例如，在32位系统中，`char`通常是1字节，`short`是2字节，`int`、`float`和`long`是4字节，`double`是8字节，所有指针的`sizeof`值也是4字节（除非是64位系统，指针可能是8字节）。 二、`sizeof`的语法： `sizeof`...
C语言—指针进阶（详解）
m0_63601181的博客
05-07 744
大家好，我是Abert，这篇文章跟大家分享指针的高阶内容。众所周知，指针堪称C语言的灵魂，掌握指针是学好C语言的关键。 这篇文章建立在上篇（初阶指针)文章的基础上进行的，建议大家配合上篇文章一起食用效果更佳。 文章目录 1.指针数组 1.1字符指针数组 1.2整形指针数组 2.数组指针 3.函数指针 4.函数指针数组 5.结构体指针 6.指针进阶题目 正文 1.指针数组 指针数组是数组，数组内存放的是指针 1.1字符指针数组 存放字符指针...
C语言进阶练习题
niubilitygeorge的博客
10-21 616
a表示数组首元素的地址，(int)a强制类型转换后，+1只会跳过1个字节，赋值给ptr2，如图所示ptr2指向第二个字节，由于ptr2是int*类型，解引用权限是4byte，所以从第二个字节开始往后数4byte，由于是小端存储模式，所以倒着取，结果是02 00 00 00，%x表示以16进制形式打印，且高位不要0，所以打印结果是2 00 00 00。，&a表示整个数组的地址，+1表示跳过整个数组后的地址，（int*)强制类型转换后赋值给ptr1，如上图所示ptr1指向数组末端。
C语言-sizeof()和strlen()求各种数组和指针的结果
normly的博客
11-09 1054
1、strlen计算字符串的具体长度 (只能是字符串)，不包括字符串结束符。返回的是字符个数。2、strlen的参数是指针类型，所以传过来的参数为指针才对。3、sizeof计算声明后所占的内存数(字节大小)，不是实际长度。4、sizeof是一个取字节运算符， 而strlen是个函数。5、sizeof的返回值=字符个数*字符所占的字节数，字符实际长度小于定义的长度，此时字符个数就等于定义的长度。若未给出定义的大小，分类讨论，对于字符串数组，字符大小等于实际的字符个数+1;
[cpp] 字符数组,字符指针,sizeof,strlen总结
weixin_30578677的博客
03-26 396
对于字符数组与字符指针: 1. 以字符串形式出现的，编译器都会为该字符串自动添加一个0作为结束符，如在代码中写"abc",那么编译器帮你存储的是"abc\0". 2. 字符串直接量作为字符指针的初始值 ＂hello＂是一个字符串直接量，编译器将其作为const char*处理，与之相关联的内存空间位于内存的只读部分，即允许编译器重用指向等价字符串直接量的引用以优化内存使用， 即使程序...
strlen和sizeof的区别
飘过的小牛
06-19 5万+
一、sizeof     sizeof(...)是运算符，而不是一个函数。     一个简单的例子： int a; cout     在头文件中typedef为unsigned int，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。     它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。     由于在编译时计算，因此sizeof不能用来返回动态分配的
c 语言中的sizeof（数组名）和sizeof(指针)
Colorful_lights的博客
04-04 3万+
sizeof（数组名）：返回数组所有元素占有的内存空间字节数。 sizeof（指针） ：返回计算机系统的地址字节数，如果是32位系统，返回4,16位系统返回2。
c语言sizeof和strlen区别
09-04
sizeof 和 strlen 是 C 语言中的两个函数，它们的作用和使用方式有一些区别。 1. sizeof 函数： - sizeof 是 C 语言中的一个操作符，用于计算变量、类型或表达式的大小（以字节为单位）。 - 它可以用于任何类型，包括基本类型（如 int、float）和用户自定义的结构体、联合体等。 - sizeof 返回的结果是一个编译时期的常量，可以在代码中使用。 - 例如，sizeof(int) 返回的结果通常为 4（在大多数平台上），表示 int 类型占用 4 个字节。 2. strlen 函数： - strlen 是 C 语言中的一个库函数，用于计算以 null 结尾的字符串的长度（不包括 null 字符）。 - 它只能用于字符串（字符数组或指针），不能用于其他类型。 - strlen 返回的结果是一个运行时期的值，表示字符串的长度。 - 例如，strlen("Hello") 返回的结果为 5，表示字符串 "Hello" 包含 5 个字符。 综上所述，sizeof 用于计算变量或类型的大小（以字节为单位），而 strlen 用于计算以 null 结尾的字符串的长度（以字符为单位）。它们在功能和使用上有明显的区别。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

伱恏呀呀呀呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值