有关数组、指针与sizeof、strlen练习题

最新推荐文章于 2023-01-29 18:44:28 发布
最新推荐文章于 2023-01-29 18:44:28 发布
阅读量120 收藏 1
点赞数
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/p_fly/article/details/125587288
版权

目录

 

一维数组练习

一维整形数组与sizeof、strlen

一维字符数组与sizeof、strlen

一维字符串数组与sizeof与strlen

常量字符串与sizeof与strlen

总结：

二维数组

总结：

指针笔试题

一维数组练习

一维整形数组与sizeof、strlen

#include<stdio.h>
int main()
{
	//一维数组
	int a[] = { 1,2,3,4 };

	printf("%d\n", sizeof(a));
	//只有数组名放到sizeof中，是代表整个数组 值=（数组内）元素个数*元素类型 4*4=16字节

	printf("%d\n", sizeof(a + 0));
	//不只有数组名了，此时a为数组首元素地址，首元素地址+0还是首元素地址
	//地址是指针变量，在不同平台下大小不一样，4或8个字节
	
	printf("%d\n", sizeof(*a));
	//不只有数组名，此时数组名为首元素地址，*首元素地址-->首元素 1是整形，所以为4个字节

	printf("%d\n", sizeof(a + 1));
	//不只有数组名，此时数组名为首元素地址，首元素地址+1，是下一个元素的地址
	//地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(a[1]));
	//a[1]是元素2，类型为整形，整形为4个字节

	printf("%d\n", sizeof(&a));
	//&数组名：取出的是整个数组的地址
	//地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(*&a));
	//先取出整个数组的地址，在解引用，那就是整个数组了
	//（数组内）元素个数*元素类型 4*4=16字节
	//直观理解为*&抵消了，只剩a

	printf("%d\n", sizeof(&a + 1));
	//先取出整个数组的地址，再+1，表示跳过整个数组，指向了下一个区域的地址
	//但本质上还是地址，地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(&a[0]));
	//a[0]是首元素，&a[0]为取出首元素的地址
	//地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(&a[0] + 1));
	//a[0]是首元素，&a[0]为取出首元素的地址，地址+1，表示指到下一个元素的地址
	//	//地址是指针变量，在不同平台下大小不一样，4或8个字节
}

一维字符数组与sizeof、strlen

#include<stdio.h>
#include<string.h>

int main()
{
	//字符数组
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));
	//sizeof(数组名)，代表计算整个数组的大小 6*1=6字节

	printf("%d\n", sizeof(arr + 0));
	//不只有数组名，arr便是首元素地址。首元素地址+0还是首元素地址
    //地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(*arr));
	//arr为首元素地址，*首元素地址，就是字符 'a'
	//'a'类型为char，为1个字节

	printf("%d\n", sizeof(arr[1]));
	//arr[1]<==>*(a+1)<==>'b'
	//'b'类型为char，为1个字节

	printf("%d\n", sizeof(&arr));
	//&数组名，取出的是整个数组的地址
	//地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(&arr + 1));
	//&数组名，取出的是整个数组的地址，然后+1是跳过arr这个数组，指向了arr后面的地址
	//地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(&arr[0] + 1));
	//&arr[0]是取出首元素的地址，地址+1下一个元素的地址
   //地址是指针变量，在不同平台下大小不一样，4或8个字节



	//strlen和sizeof不一样，它是计算从起始地址到'\0'之前所出现的字符个数的

	printf("%d\n", strlen(arr));
	//arr为首元素地址，但是该数组没有'\0'，所以会是随机值

	printf("%d\n", strlen(arr + 0));
	//arr为首元素地址，+0还是指向首元素地址，同上还是随机值

	printf("%d\n", strlen(*arr));
	//strlen内应该传其实地址，这里arr为首元素地址，又解引用，就是字符'a'
	//也就是strlen(97)，它就是野指针

	printf("%d\n", strlen(arr[1]));
	//与上一种情况一样，为野指针

	printf("%d\n", strlen(&arr)); 
	//&arr是取出了整个数组的地址，整个数组的地址与首元素地址相同
	//又因为没有'\0'，所以会是随机值

	printf("%d\n", strlen(&arr + 1));
	//&arr取出整个数组的地址，+1跳过整个数组
	//其实地址有了，但是还是不知道'\0'在哪，所以还是随机值

	printf("%d\n", strlen(&arr[0] + 1));
	//取出首元素的地址+1，得到了第二个元素的地址
	//但是还是不知道'\0'，所以还是随机值

	return 0;
}

一维字符串数组与sizeof与strlen

#include<stdio.h>
#include<string.h>

int main()
{
	char arr[] = "abcdef";
	//与上面的数组不一样的地方是，这个字符串后面默认隐藏了'\0'
	//相当于上面char arr[] = {'a','b','c','d','e','f','\0'};

	printf("%d\n", sizeof(arr));
	//sizeof(数组名)，算整个数组的大小 7*1=7字节

	printf("%d\n", sizeof(arr + 0));
	//不只有数组名，arr代表首元素地址，+0还是首元素地址
	//地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(*arr));
	//arr为首元素地址，解引用为首元素'a'
	//'a'的类型为char，大小为1个字节

	printf("%d\n", sizeof(arr[1]));
	//arr[1]<==>*(a+1)<==>'b'  大小为1个字节

	printf("%d\n", sizeof(&arr));
	//&数组名，取出的是整个数组的地址
    //地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(&arr + 1));
	//&数组名，取出的是整个数组的地址，然后+1是跳过arr这个数组，指向了arr后面的地址
	//地址是指针变量，在不同平台下大小不一样，4或8个字节

	printf("%d\n", sizeof(&arr[0] + 1));
	//&arr[0]是取出首元素的地址，地址+1下一个元素的地址
    //地址是指针变量，在不同平台下大小不一样，4或8个字节



	printf("%d\n", strlen(arr));
	//arr为首元素地址，同时也有'\0'，它们之间又6个字符

	printf("%d\n", strlen(arr + 0));
	//arr为首元素地址，+0没有跳过任何地址，所以还是六个字符

	//printf("%d\n", strlen(*arr));
	//arr为首元素地址，解引用为首元素'a'
	//strlen(97)，97为野指针

	//printf("%d\n", strlen(arr[1]));
	//同上，是第二个元素'b'
	//也是野指针

	printf("%d\n", strlen(&arr));
	//&arr为取出整个数组的地址，整个数组的地址与首元素的地址一样
	//所以找到'\0'之间的元素个数为6

	printf("%d\n", strlen(&arr + 1));
	//&arr为取出整个数组的地址，+1就是跳过整个数组的地址
	//地址有了，但是不知道'\0'在哪里，所以为随机值

	printf("%d\n", strlen(&arr[0] + 1));
	//&arr[0]是取出首元素的地址，+1就是往后跳过一个元素
	//从第二个字符的地址开始，到'\0'之间的元素个数为5

	return 0;
}

常量字符串与sizeof与strlen


#include<stdio.h>
#include<string.h>

int main()
{
	char* p = "abcdef";
	//这里是一个常量字符串，常量字符串的内容是不可修改的
	//且这里的末尾也隐藏了'\0'
	//p只是保存了首元素'a'的地址

	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) 还是对首元素地址解引用，同上为1字节

	printf("%d\n", sizeof(&p));
	//p为char*类型，&p为char**，二级指针的大小依旧是4或8个字节

	printf("%d\n", sizeof(&p + 1));
	//&p+1为二级指针往后跳过刚才一级指针的位置，也就是跳过了p的地址
	//最后还是指向了一个地址，所以还是4或8个字节

	printf("%d\n", sizeof(&p[0] + 1));
	//&p[0]+1<==>&*(p+0)+1<==>p+1就是b的地址，所以为4或8个字节



	printf("%d\n", strlen(p));
	//p为首元素的地址，找到了地址，也有'\0'，之间的元素个数为6

	printf("%d\n", strlen(p + 1));
	//首元素地址+1是跳过了第一个元素，所以此时计算的元素个数为5

	printf("%d\n", strlen(*p));
	//解引用首元素地址，那就是'a'，写法不对

	printf("%d\n", strlen(p[0]));
	//p[0]<==>*(p+0)，还是相当于解引用首元素地址，'a'，写法不对

	printf("%d\n", strlen(&p));
	//取出存储首元素地址的地址，这就是另外一个空间了
	//有地址，但不知道'\0'何时出现，那就是随机值

	printf("%d\n", strlen(&p + 1));
	//同上还是随机值，但二者的随机值没有联系

	printf("%d\n", strlen(&p[0] + 1));
	//从'b'的地址开始计算，所以有5个字符。

	return 0;
}

总结：

一维数组数组名大多数情况下都代表首元素地址。

但是有两个例外，数组名代表整个数组

a.sizeof(数组名)    注意：（）中必须只有数组名才能代表整个数组

b.&数组名    注意：虽然&数组名和首元素地址值一样。但是对于指针，我们要关注类型，类型能够决定指针+-整数跳过的步长（单位字节）和解引用访问的权限。&数组名类型就是数组指针类型。

二维数组

#include<stdio.h>
#include<string.h>

int main()
{
	int a[3][4] = { 0 };

	printf("%d\n", sizeof(a));
	//sizeof()只有数组名，代表整个数组的大小 3*4*4=48字节

	printf("%d\n", sizeof(a[0][0]));
	//a[0][0]访问的元素为0，sizeof(0)=4

	printf("%d\n", sizeof(a[0]));
	//类比
	//一维数组              二维数组
	//a1[i]                 a2[i][j]
	//这里的a1是数组名       二维数组的a2[i]不就是恰好对应上一维数组的a1，所以a[i]就相当于一维数组名
	
	//a[0]就是这个二维数组的第一行数组名
	//数组名单独放到sizeof()就是计算第一行数组的大小
	//4*4=16

	printf("%d\n", sizeof(a[0] + 1));
	//sizeof()不仅仅有数组名，那就不是整个数组的大小了
	//此时a[0]为第一行首元素的地址，+1那就是第一行第二个元素的地址，地址为4或8个字节
	//a[0]相当于&a[0][0]，&a[0][0]+1相当于&a[0][1]  

	printf("%d\n", sizeof(*(a[0] + 1)));
	//a[0]+1同上，解引用那就是访问a[0][1]的元素0，整形的字节大小为4个字节

	printf("%d\n", sizeof(a + 1));
	//a没有单独放在sizeof内部，也没有&a
	//此时这里的a就是二位数组首元素地址，二维数组首元素地址就是二维数组第一行地址
	//a+1就是跳过第一行的地址，表示第二行的地址，所以为4或8个字节

	printf("%d\n", sizeof(*(a + 1)));
	//a+1同上，解引用那就是第二行的数组，大小为4*4=16
	//还可以这样理解*(a+1)-->a[1]
	//sizeof(a[1])就是计算第二行数组的大小

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

	printf("%d\n", sizeof(*(&a[0] + 1)));
	//&a[0]+1同上
	//在解引用就是整个第二行的元素，4*4=16

	printf("%d\n", sizeof(*a));
	//a未放在sizeof()内部，也没有&a
	//a就是二维数组首元素地址，二维数组首元素地址就是二维数组第一行地址
	//在解引用那就是第一行的元素 4*4=16

	printf("%d\n", sizeof(a[3]));
	//a[3]应该是整个第四行数组，4*4=16
	//不存在越界访问，因为只是使用了其数组名，并未访问内部元素

	return 0;
}

总结：

二位数组的数组名与一维数组有相同之处

以int a[3][4]这个二维数组举例

对于数组名a来说，如果单独放在sizeof()或者&a的话，那就是代表整个数组

                               其他情况就是代表二维数组首元素地址

                               二维数组首元素地址就是二维数组第一行的地址，即&a[0]

对于a[0]来说，如果单独放在sizeof()或者&a[0]的话，那就是代表第一行的整个地址

                                其他情况就是代表二维数组第一行首元素地址，即&a[0][0]

指针笔试题

1.

#include<stdio.h>

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

小结：

        指针变成另一种指针时，虽然还是指向相同的地址，但是其解引用权限和步长都会发生改变

2.

#include<stdio.h>

//x86环境下，以下结构体的大小是20个字节
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}* p = 0x00100000;

//假设p 的值为0x00100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
	printf("%p\n", p + 0x1);
	//p为结构体类型指针变量，+1就是跳过一个结构体Test
	//已知题目变量大小为20字节，而题目当中是以 %p 的形式打印，是以十六进制打印
	//十进制20转十六进制为14
    //0x00100000+0x00000014=0x00100014

	printf("%p\n", (unsigned long)p + 0x1);
	//p的类型被强制转换成无符号长整型
	//此时0x00100000为16进制的整数，再+16进制的整数0x1
	//那就是0x001000001

	printf("%p\n", (unsigned int*)p + 0x1);
	//先把p强制转化成无符号整形指针类型
	//再+1，就相当于跳过一个无符号整形的长度（4个字节）
	//0x00100000+0x00000004=0x00100004

	return 0;
}

小结：加减看类型，整数加减与我们平时计算的没差

                                 指针加减整数就是以不同指针类型的意义跨距离

3.

#include<stdio.h>

int main()
{
	int a[4] = { 1, 2, 3, 4 };
	int* ptr1 = (int*)(&a + 1);
	int* ptr2 = (int*)((int)a + 1);
	printf("%x,%x\n", ptr1[-1], *ptr2);
	//ptr1[-1] --> *(ptr1-1)
	//%x 以十六进制的形式打印
	return 0;
}

4.

#include<stdio.h>

int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
	//注意对比int a[3][2]={ {0,1}, {2,3}, {4,5} };
	//这个才是二位数组的赋值，而 （,）是逗号表达式
	//实际相当于 int a[3][2]={1,3,5};
	int* p;
	p = a[0];
	//a[0]第一行数组名
	//a[0]既没有放到sizeof内部也没有取地址
	//a[0]就是二维数组第一行首元素的地址，即&a[0][0]
	printf("%d", p[0]);
	//p[0] --> *(p+0)
	return 0;
}

5.

#include<stdio.h>
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.

#include<stdio.h>
int main()
{
	int a[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* ptr1 = (int*)(&a + 1);
	int* ptr2 = (int*)(*(a + 1));
	printf("%d,%d\n", *(ptr1 - 1), *(ptr2 - 1));
	return 0;
}

7.

#include<stdio.h>

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

8.

#include<stdio.h>
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;
}

 

有什么错误希望评论区可以指出来。

p_fly
关注
专栏目录
sizeof及常见考题
myself00的专栏
10-27 2950
sizeof是C/C++中的关键字，它是一个运算符，其作用是取得一个对象(数据类型或者数据对象)的长度(即占用内存的大小，以byte为单位)。 在C++中，变量和自定义类型可以不用加（），内置类型要加。 需要注意的点包括： 1）它是运算符，不是函数； 2）sizeof不能求得void类型的长度； 下面两种情况都会编译出错， sizeof (void );   
C语言数组与指针常考笔试题（原题+解析+原码）
未见花闻的博客
09-16 3564
⭐️前面的话⭐️ 大家好！对于数组与指针你们会了吗？准备了一些相关的笔试题，测一测你全部会了吗？如果能轻松回答正确，恭喜你，指针与数组已经学得非常扎实了，超过了90%的同龄人！
C++ sizeof()练习
acxm45824的博客
06-25 157
class A { int a; short b; int c; char d; }; class B { double a; short b; int c; char d; }; 在32位机器上用gcc编译以上代码，求sizeo...
sizeof相关的习题
m0_74234485的博客
01-29 592
1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。 (放地址情况都视为sizeof（指针），4/8) 2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。 3. 除此之外所有的数组名都表示首元素的地址。
指针和数组习题（sizeof()和strlen())
weijie_win的博客
11-16 89
总结： 数组名的意义： 1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。 2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。 3. 除此之外所有的数组名都表示首元素的地址 // 一维数组 int a[] = { 1, 2, 3, 4 }; printf("%d\n", sizeof(a));//16；整个数组的大小 printf("%d\n", sizeof(a + 0));//4；1的地址 printf("%d\n", sizeof(*a
C/C++中sizeof()计算练习题
qq_43700779的博客
03-08 940
1.sizeof() sizeof() 操作符的结果类型为 size_t，计算的是分配空间的实际字节数； sizeof() 是运算符，可以以类型、函数做参数； sizeof() 是在编译的时候就将结果计算出来了，结果是类型所占空间的字节数，所以用数组名做参数计算的是整个数组的大小。 2.strlen() strlen() 结果类型也是 size_t，但 strlen() 计算的是空间中字符的个数，不包括 ‘\0’; strlen() 是函数，只能以 char* (字符串)做参数，而且，一定要以 ‘\0’ 结
指针和数组练习题
zhao19971014的博客
03-27 529
//练习1 //一维数组 #include <stdio.h> //数组名是什么呢？ //数组名通常上来说是数组首元素的地址 //但是有2个例外 //1.sizeof（数组名），这里的数组名表示整个数组，计算的是整个数组的大小 //2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址 int main() { int a[] = { 1,2,3,4 }; // 0 1 2 3 printf("%d\n", sizeof(a));//4*4=16 .
sizeof和strlen练习题
weixin_45258996的博客
03-16 123
#include <stdio.h> #include <string.h> int main() { ///////////////////////////////////////// // 第一组 ///////////////////////////////////////// // char[6] // char arr[] = { 'a', 'b', 'c', '...
60+道经典指针与数组笔试题——C语言
weixin_59913110的博客
07-02 2061
本篇的内容主要围绕指针与数组、指针与字符串等之间的关系，以及进一步理解 sizeof 、strlen 的使用与意义。数组是指具有相同类型元素的集合，字符串常量是一个指向在连续空间里存放的字符的首字符的地址的指针。我们会在下面理解数组与字符串数组的不同。sizeof 是一个操作符，是计算类型空间大小的。strlen 是针对字符串的库函数，用来求字符串的长度。对于数组来说，数组名都是首元素地址，除了这两种情况外：我们的目的是求下面各个 printf 语句输出什么。 2.2字符数组 我
指针知多少（指针进阶习题讲解：数组篇）
qq_52989768的博客
01-21 969
指针进阶的内容基本介绍完毕，如果你自我感觉不错，没有对里面的内容感到迷惑的话，那么我们就开始下面的内容 目录 1.一维数组 1.1int型 1.2字符串 2.二维数组 1.一维数组 1.1int型 首先看下面的代码： int a[] = {1,2,3,4}; printf("%d\n",sizeof(a)); printf("%d\n",sizeof(a+0)); printf("%d\n",sizeof(*a)); printf("%d\n",sizeof(a+1)); printf(
关于sizeof的题目
Holi的专栏
10-04 523
关于sizeof的题目遇到了很多次，直到今天我才决定把我做过的题目在电脑上运行一下，真是不看不知道，一看吓一跳，原来已经做错了两次这样的题目了。（事不过三）     先看题目:在32位系统下的C/C++程序，请计算sizeof的值。     void *p = malloc(100);     sizeof(p) = ?     已经做了两次这样的题目，都是想直接写个100
C语言简单练习题（适用于初学者）——No.3，关于sizeof
Sky*殇的博客
01-21 166
C语言简单练习题，关于 sizeof
C++笔试面试中的sizeof常见题目
BlueBirdssh的专栏
10-23 385
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/z914022466/article/details/73770311 以下所有问题均为32位操作系统 #include <iostream> #include <string> using std::co...
(详解)sizeof与strlen加简单例题
k5426244的博客
09-19 1116
sizeof和strlen详解
常见sizeof 笔试题
weixin_30780649的博客
03-20 105
最近面试过程中遇到了很多很多sizeof的问题。 现在总结一下： #include <stdio.h> #include <string.h> void fun(int array[], char *str) { printf("sizeof(array) : %d\n", sizeof(array)); printf("sizeof(...
sizeof 笔试题
zgbsoap的专栏
05-13 1483
 http://www.xici.net/b700278/d44576087.htm1.常规char  str1[] = “Hello” ;char  str2[5] = {H,e,l,l,o};char  str3[6] = {H,e,l,l,o,/0};char   *p1 = "Hello";char  *p2[]={"hello","worl
c语言中的sizeof(面试、笔试常考)
whusl的专栏
09-26 539
大部分公司在招聘技术职位面试的时候，都会考c语言基础，而sizeof是他们最喜欢考的知识点，现总结如下： 1、定义 sizeof是C语言的一种单目操作符，它并不是函数。sizeof操作符以字节形式给出了其操作数所占存储空间的大小。操作数可以是一个表达式或括在括号内的类型名。操作数所占存储空间的大小由操作数的类型决定。作用就是返回一个对象或者类型所占的内存字节数。 2、语法 sizeo...
sizeof语法
msgsnd的专栏
03-13 1092
一、语法1 sizeof有三种语法形式1) sizeof( object ); // sizeof( 对象 );2) sizeof( type_name ); // sizeof( 类型 );3) sizeof object; // sizeof 对象;int i;sizeof( i ); // oksizeof i; // oksizeof( int ); //
sizeof（）与strlen（）复习总结（大量例题）
请叫我皮皮虾的博客
07-17 795
strlen（）用于求字符串的长度，针对的对象是字符串，不包括结束符‘\0’； sizeof（）用于求所占空间大小，针对的是类型，包括‘\0’； 注：首先大家要明确一个概念，strlen()是函数，sizeof()表面看起来是函数，但其本质是关键字。 话不多说，直接上题~ 例： #include<iostream> #include<string.h> ...
c语言函数与指针练习题
最新发布
12-17
以下是两个关于C语言函数与指针的练习题的例子： 1. 使用strlen函数获取字符串长度 ```c #include #include int main() { char arr[] = "hello hit"; int len = strlen(arr); printf("%d", len); // 输出：9 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值