C语言指针（5）：strlen与sizeof的区别及指针笔试题练习

已于 2024-03-10 10:26:56 修改
阅读量993 收藏 19
点赞数 24
文章标签： c语言
于 2024-03-06 20:26:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zy1215058242/article/details/136508641
版权

1、sizeof和strlen的对比

sizeof

        sizeof计算变量所占内存内存空间⼤⼩的，单位是字节，如果操作数是类型的话，计算的是使⽤类型创建的变量所占内存空间的⼤⼩。简单来说，sizeof 只关注占⽤内存空间的⼤⼩，不在乎内存中存放什么数据。

#inculde <stdio.h>
int main()
{
 int a = 10;
 printf("%d\n", sizeof(a));
 printf("%d\n", sizeof a);//从这里可以看出sizeof是操作符而不是函数，因为函数调用必须有函数调用操作符（）。
 printf("%d\n", sizeof(int));
 
 return 0;
}

strlen

        strlen是C语言中的一个库函数，功能是求字符串的长度。函数原型为：

size_t     strlen ( const char * str );
        strlen 统计的是从 strlen 函数的参数 str 中这个地址开始向后， \0 之前字符串中字符的个数。如果找不到 \0 ，就会一直向后访问，直到找到为止，所以可能存在越界访问查找。
         
#include <stdio.h>
int main()
{
 char arr1[3] = {'a', 'b', 'c'};
 char arr2[] = "abc";
 printf("%d\n", strlen(arr1));
 printf("%d\n", strlen(arr2));
 
 printf("%d\n", sizeof(arr1));
 printf("%d\n", sizeof(arr1));
 return 0;
}

        如果多次输出结果，你会发现第一个值会不断变化，并且是随机的。这里就体现了strlen的性质，因为arr1中存放的只有abc三个字符，后面没有跟 \0 ，所以函数没有停止，会在c的地址继续向后访问。

sizeof 和 strlen的对比

sizeof
1. sizeof是操作符
2. sizeof计算操作数所占内存的⼤⼩，单位是字节（指针大小：32位：4  /64位：8）
3. 不关注内存中存放什么数据

 strlen

1. strlen是库函数，使⽤需要包含头⽂件 string.h
2. srtlen是求字符串⻓度的，统计的是 \0 之前字符的隔个数
3. 关注内存中是否有 \0 ，如果没有 \0 ，就会持续往后找，可能会越界

 数组和指针笔试题分析

        

        一维数组

int a[] = {1,2,3,4};
//arr是有四个整型元素的数组
printf("%d\n",sizeof(a));
//sizeof(a)是计算的整个数组的大小，16个字节
printf("%d\n",sizeof(a+0));
//sizeof(a+0)是计算的数组首元素的地址的大小，4/8个字节
printf("%d\n",sizeof(*a));
//sizeof(*a)是计算的数组首元素的大小，4个字节
printf("%d\n",sizeof(a+1));
//sizeof(a+1)是计算的数组第二个元素的地址的大小，4/8个字节
printf("%d\n",sizeof(a[1]));
//sizeof(a[1]) == sizeof(*(a+1))
//计算的是数组第二个元素的大小，4个字节
printf("%d\n",sizeof(&a));
//sizeof(&a)是计算的整个数组的地址的大小，4/8个字节
printf("%d\n",sizeof(*&a));
//sizeof(*&a) == sizeof(a)
//计算的是整个数组的大小，16个字节
printf("%d\n",sizeof(&a+1));
//sizeof(&a+1)计算的是a数组后相同空间的地址的大小，4/8个字节
printf("%d\n",sizeof(&a[0]));
//sizeof(&a[0])是计算的第一个元素的地址的大小，4/8个字节
printf("%d\n",sizeof(&a[0]+1));
//sizeof(&a[0]+1)是计算的第二个元素的地址的大小，4/8个字节

字符数组

代码段1：

char arr[] = {'a','b','c','d','e','f'};
//arr数组是存放了a~f 6个字符的数组
printf("%d\n", sizeof(arr));
//sizeof(arr)计算的是整个数组的大小，6个字节
printf("%d\n", sizeof(arr+0));
//sizeof(arr+0)计算的是数组首元素的地址的大小，4/8个字节
printf("%d\n", sizeof(*arr));
//sizeof(*arr)计算的是数组首元素的大小，1个字节
printf("%d\n", sizeof(arr[1]));
//sizeof(arr[1]) == sizeof(*(arr+1))
//计算的是数组第二个元素的大小，1个字节
printf("%d\n", sizeof(&arr));
//sizeof(&arr)计算的是整个数组的地址的大小，4/8个字节
printf("%d\n", sizeof(&arr+1));
//sizeof(&arr+1)计算的是数组地址后与数组大小相同的空间内的地址的大小，4/8个字节
printf("%d\n", sizeof(&arr[0]+1));
//sizeof(&arr[0]+1)计算的是数组第二个元素的地址的大小，4/8个字节

代码段2：

char arr[] = {'a','b','c','d','e','f'};
//arr数组是存放了a~f 6个字符的字符数组
printf("%d\n", strlen(arr));
//strlen(arr)计算的是从字符a开始到首个\0之前的元素个数，因为\0位置随机，所以结果为随机值x。
printf("%d\n", strlen(arr+0));
//strlen(arr+0)计算的是从字符a开始到首个\0之前的元素个数，因为\0位置随机，所以结果为随机值x。
printf("%d\n", strlen(*arr));
//strlen(*arr)表示的是a字符即ascll值97的地址位置为起始，首个\0之前的元素个数，但因为起始地址为不可访问地址，所以会报错，运行失败。
printf("%d\n", strlen(arr[1]));
//strlen(arr[1])表示的是b字符即ascll值98的地址位置为起始，首个\0之前的元素个数，但因为起始地址为不可访问地址，所以会报错，运行失败。
printf("%d\n", strlen(&arr));
//strlen(&arr)：&arr表示整个数组的地址，同样表示数组首元素的地址，所以计算的是从字符a开始到首个\0之前的元素个数，因为\0位置随机，所以结果为随机值x。
printf("%d\n", strlen(&arr+1));
//strlen(&arr+1)：&arr+1表示数组后与数组空间相同大小的内存处的地址，所以计算的是从字符f后一个位置开始到首个\0之前的元素个数，因为\0位置随机，所以结果为随机值x-6。
printf("%d\n", strlen(&arr[0]+1));
//strlen(&arr[0]+1)：&arr[0]+1表示的是数组第二个元素的地址，所以计算的是从字符b开始到首个\0之前的元素个数，因为\0位置随机，所以结果为随机值x-1。

将两个报错代码屏蔽后：

字符串数组

代码段1：

char arr[] = "abcdef";
//arr数组是存放了字符串“abcdef\0”的字符串数组。
printf("%d\n", sizeof(arr));
//sizeof(arr)计算的是整个数组的元素大小，7个字节
printf("%d\n", sizeof(arr+0));
//sizeof(arr+0)计算的是数组首元素的地址的大小，4/8个字节
printf("%d\n", sizeof(*arr));
//sizeof(*arr)计算的是数组首元素的大小，1个字节
printf("%d\n", sizeof(arr[1]));
//sizeof(arr[1])计算的是数组第二个元素的大小，1个字节
printf("%d\n", sizeof(&arr));
//sizeof(&arr+1)表示的是整个数组的地址的大小，4/8个字节
printf("%d\n", sizeof(&arr+1));
//sizeof(&arr+1)表示的是整个数组地址+1的地址的大小，4/8个字节
printf("%d\n", sizeof(&arr[0]+1));
//sizeof(&arr[0]+1))表示的是数组第二个元素的地址，4/8个字节

代码段2：

char arr[] = "abcdef";
//arr数组是存放了字符串“abcdef\0”的字符串数组。
printf("%d\n", strlen(arr));
//strlen(arr)计算的是从a字符到第一个\0之前的元素个数，因为字符串末尾隐藏了一个\0，所以大小为6
printf("%d\n", strlen(arr+0));
//strlen(arr+0)计算的是从数组首元素的地址到\0之前的元素个数，大小为6
printf("%d\n", strlen(*arr));
//strlen(*arr)计算的是数组从以首元素的ascll值为地址的元素到第一个\0之前的元素个数，因为该地址不可访问，所以会报错。
printf("%d\n", strlen(arr[1]));
//计算的是数组从以第二个元素的ascll值为地址的元素到第一个\0之前的元素个数，因为该地址不可访问，所以会报错。
printf("%d\n", strlen(&arr));
//strlen(&arr)：表示的是整个数组的地址到第一个\0之前的元素个数，整个数组的地址 == 首元素地址。
//大小为6
printf("%d\n", strlen(&arr+1));//因为起始位置是字符串末尾的\0之后，下一个\0位置未知，所以结果为随机值
printf("%d\n", strlen(&arr[0]+1));
//strlen(&arr[0]+1)表示的是数组第二个元素到字符串末尾\0之前的元素个数，大小为5.

将报错代码注释掉后：

代码段3：

char *p = "abcdef";
//p为指针变量，指向的是字符串的首元素a的地址。
printf("%d\n", sizeof(p));
//sizeof(p)：p为指针变量，所以大小为4/8个字节
printf("%d\n", sizeof(p+1));
//sizeof(p+1)表示的是字符串中第二个元素b的地址的大小，4/8个字节
printf("%d\n", sizeof(*p));
//sizeof(*p)表示的是字符串首元素a的大小，1个字节（char）
printf("%d\n", sizeof(p[0]));
//sizeof(p[0])表示的是a的大小，1个字节（char）
printf("%d\n", sizeof(&p));
//sizeof(&p)表示的是指针变量p的地址的大小，4/8个字节
printf("%d\n", sizeof(&p+1));
//表示的是p的地址+1处的地址的大小，4/8个字节
printf("%d\n", sizeof(&p[0]+1));
//sizeof(&p[0]+1)表示的是字符串内第二个元素的地址的大小，4/8个字节

代码段4：

char *p = "abcdef";
//p是指针变量，指向字符串的元素的的地址
printf("%d\n", strlen(p));
//strlen(p)计算的是以p指针指向的地址为起始位置，到第一个\0之前的元素个数，大小为6
printf("%d\n", strlen(p+1));
//strlen(p+1)计算的是以p指针+1指向的地址为起始位置，到第一个\0之前的元素个数，大小为5
printf("%d\n", strlen(*p));//报错，解释同前
printf("%d\n", strlen(p[0]));//报错，解释同前
printf("%d\n", strlen(&p));
//strlen(&p)表示的是p指针变量的地址，\0位置不确定，所以大小为随机值
//从p这个指针变量的起始位置开始向后数的，p变量存放的地址是什么，不知道，所以答案是随机值
printf("%d\n", strlen(&p+1));
//strlen(&p+1)表示的是p指针变量+1的地址，\0位置不确定，所以大小为随机值
printf("%d\n", strlen(&p[0]+1));
//strlen(&p[0]+1)表示的是b的地址，计算的是以b的地址为起始位置，到第一个\0之前的元素个数，大小为5

二维数组

二维数组名的意义：
1. sizeof(数组名)，这⾥的数组名表⽰整个二维数组，计算的是整个二维数组的⼤⼩。
2. &数组名，这⾥的数组名表⽰整个二维数组，取出的是整个二维数组的地址。
3. 除此之外所有的数组名都表⽰⾸元素（首行）的地址。 
int a[3][4] = {0};
//a是三行四列的二维数组，并且全部初始化为0
printf("%d\n",sizeof(a));
//sizeof(a)计算的是整个二维数组的大小，12*4 = 48个字节
printf("%d\n",sizeof(a[0][0]));
//sizeof(a[0][0])计算的是数组首行首元素的大小，大小为4个字节
printf("%d\n",sizeof(a[0]));
//sizeof(a[0])计算的是数组首行的元素的大小，大小为16个字节
printf("%d\n",sizeof(a[0]+1));
//sizeof(a[0]+1)计算的是数组首行第二个元素的地址的大小，大小为4/8个字节
printf("%d\n",sizeof(*(a[0]+1)));
//计算的是数组首行第二个元素的大小，4个字节
printf("%d\n",sizeof(a+1));
//sizeof(a+1)计算的是数组第二行的地址的大小4/8个字节
printf("%d\n",sizeof(*(a+1)));
//sizeof(*(a+1))计算的是数组第二行的元素的大小，16个字节
printf("%d\n",sizeof(&a[0]+1));
//sizeof(&a[0]+1)计算的是数组第二行的地址的大小，4/8个字节
printf("%d\n",sizeof(*(&a[0]+1)));
//sizeof(*(&a[0]+1))计算的是数组第二行元素的大小，16个字节
printf("%d\n",sizeof(*a));
//sizeof(*a)计算的是数组首行元素的大小，16个字节
printf("%d\n",sizeof(a[3]));
//表示的是数组越界访问的第四行的元素大小，16个字节

3、指针运算笔试题解析  

题目一：

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

 题目二：

// 在 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 );
printf ( "%p\n" , ( unsigned int *)p + 0x1 );
return 0 ;
}

 题目三：

# include <stdio.h>
int main ()
{
int a[ 3 ][ 2 ] = { ( 0 , 1 ), ( 2 , 3 ), ( 4 , 5 ) };
int *p;
p = a[ 0 ];
printf ( "%d" , p[ 0 ]);
return 0 ;
}
        这道题很容易让人进坑。
        题目中给的数组是由三个逗号表达式组成的数组，本质上是赋了3个初值，如果你当成了6个数，那就翻车了。
        结果：1

 题目四：

// 假设环境是 x86 环境，程序输出的结果是啥？
# 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 ;
}

因为二维数组在内存中是连续存放的，所以图如下：

         p是int (*)[4]类型，说明p一行只能存四个元素。也就是说，数组指针变量p的第一行是a[0]的第一行的前四个元素，p的第二行是a[0]的第五个元素，和a[1]的前三个元素，依次向后。
         &p[ 4 ][ 2 ] - &a[ 4 ][ 2 ] 是指针-指针的运算，之前有讲过指针-指针的绝对值得到的是指针和指针之间的元素个数。&p[4][2] == &a[3][3]，所以  &p[ 4 ][ 2 ] - &a[ 4 ][ 2 ]的结果为-4.
-4用%d打印的结果就是-4，用%p打印需要进行原反补码的转换，
-4的原码是10000000000000000000000000000100  除符号位，其他位按位取反
-4的反码是111111111111111111111111111111111011  反码+1
-4的补码是111111111111111111111111111111111100  
因为是32位的环境转换成十六进制就是FFFFFFFC

题目五：

 #include <stdio.h>

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

 

结果：

题目六：

# include <stdio.h>
int main ()
{
char *a[] = { "work" , "at" , "alibaba" };
char **pa = a;
pa++;
printf ( "%s\n" , *pa);
return 0 ;
}
上图就是变量初始化后的结果，pa++使其指向a[1]，*pa即a[1]指向的'a'的地址，用%s打印，遇到\0才结束，所以打印结果位“at”。

题目七：

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

 

（1） printf("%s\n", **++cpp);

++cpp 使cpp指向cp[1]，两次解引用，表示为’p‘的地址，%s打印结果为POINT.

(2)printf("%s\n", * -- * ++ cpp + 3);

+加法操作符的优先级最小，所以+3最后计算。

++cpp 使cpp指向cp[2]，一次解引用表示的使cp[2]中的内容c+1，前置--使内容变为c，解引用指向c[0]，即’E‘的地址，+3指向第二个’E‘，%s打印的结果为"ER"

(3)printf("%s\n", *cpp[-2]+3);

cpp[-2] == *(cpp-2),并不会改变cpp的指向的地址，过程与上一问一致结果为ST。

(4)printf("%s\n", cpp[-1][-1]+1);

cpp[-1][1] == *(*(cpp-1)-1) ,先把cpp指向cp[1]，然后解引用，表示内容c+2，-1使内容变为c+1，解引用指向c[1]，结果为NEW.

问天要一物
关注
  • 24
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
笔试面试题目：一文搞定sizeof笔试面试题
认知 行动 坚持
02-17 1805
在面试C/C++相关的岗位时，sizeof操作符几乎是必考内容，它能检验面试者的基本功，所以，只能全对，不能出错。一起来看看，这些题目，你能全做对吗？说明：如下题目是基于64位平台。
指针进阶的笔试题练习1
08-08
本题主要涉及到了指针、数组和字符串的使用，以及它们在内存中的表示和操作。下面将详细解释这些知识点： 1. **二维数组与指针**： - `int a[3][4]` 定义了一个3行4列的二维数组。`sizeof(a)`返回整个数组所占的...
常考笔试题,详细解剖C++运算符sizeof()的使用及字节对齐问题
lannykuaile的专栏
04-10 563
先看题目: [cpp] view plaincopy struct A{           char c1;        short s1;        char c2;        float f1;       double d1;   };       struct B{       char c1;         c
15.2 C语言指针 有关sizeof 的数组和指针笔试题解析
MONICA_CZT的博客
09-04 61
❗注意：地址内存大小在x64环境下是8个字节，在x86环境下是4个字节。不同的环境对类型的大小无影响。
C语言sizeof与strlen详解（附大量笔试题题解过程）
chuxinchangcun的博客
09-10 8191
一.sizeof()详解 二.strlen()详解 strlen()的模拟实现： 法1：计数器 法2：指针-指针 法3：递归 三.strlen与sizeof的区别 四.笔试题 1.整形数组int a[] = {1,2,3,4} strlen()相关题目 sizeof()相关题目 2.字符数组-char arr[] = {'a','b','c','d','e','f'} strlen()相关题目 sizeof...
【C语言进阶刷题笔记】strlen和sizeof经典笔试题
ljp
11-01 679
sizeof()是运算符，其值在编译时就已经计算好了,参数可以是数组、指针、类型、对象、函数等。 它的功能是：获得保证能容纳实现所建立的最大对象的字节大小,简单点说就是计算变量或者类型所占的字节大小。 strlen（）是函数，要在运行时才能计算。参数必须是字符型指针（char*）。当数组名作为参数传入时，实际上数组就退化成指针了。 它的功能是：返回字符串的长度。 该字符串可能是自己定义的，也可能是内存中随机的，该函数实际完成的功能是从代表该字符串的第一个地址开始遍历，直到遇到结束符’\0’停止。
c语言笔试题
07-14
【C语言笔试题】主要考察的是对C语言基础概念、语法特性和编程技巧的理解。下面分别解析题目中涉及的知识点： 1. 在第一段代码中： ```c int main() { int a = 0x500; int b = 0x518; int *p1 = (int*)0x500; ...
C语言笔试试题汇集(超经典).doc
11-12
sizeof指针和数组的长度 Sizeof与Strlen的区别 stack和heap的区别 大小端存储情况 strcut的指针p+0x200=? (long)p+0x200=? (long *)p+ox200=? 数组地址偏移算法 const用法 static作用 volatile作用 线程间通信的机制
二级C语言精选笔试题.pdf
06-02
"二级C语言精选笔试题.pdf" 本资源摘要信息涵盖了C语言的基础知识点，包括C语言程序的基本单位、基本结构、函数调用、数据类型、运算符、数组、指针、函数返回值类型、文件存取方式等知识点。 1. C语言程序的基本...
[C语言面试笔试]2023精选填空题.doc
08-27
C 语言面试笔试精选填空题 C 语言是一种广泛使用的编程语言，面试中经常会遇到填空题类型的题目。这类题目旨在考察考生的编程基础知识和逻辑思维能力。下面我们将对给定的文件信息进行分析，并从中提取相关的知识点...
sizeof笔试题
qq_38475134的博客
10-15 268
#include<stdlib.h> #include<stdio.h> int main(void) { char str[] = "hello"; char *p = str; int n = 10; int a[5]; char *ptr = (char*)malloc(100); struct s1{ char z; ...
sizeof运算与strlen函数的面试笔试题(排版很舒服)
2302_76941579的博客
09-07 252
1.一维数组1.一维数组大家可以先做一下，下面有解释。
【c语言】关于指针和数组的简单笔试题
Zhutiy的博客
05-03 105
首先上结论： 1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。 2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。 3. 除此之外所有的数组名都表示首元素的地址。 关于 sizeof 和 strlen ： 1.sizeof 是操作符，只关注占用内存的大小，单位是字节，不关心内存中放的是什么。 2.strlen 是库函数，统计的是'\0'之前出现的字符的个数，一定要找到'\0'
sizeof()与strlen()在指针和数组笔试题（超详细绝对有帮助）
m0_72161237的博客
09-07 635
sizeof 是计算对象或者类型创建的对象所占内存空间的大小，单位是字节，在计算字符串的空间大小时，包含了结束符\0的位置 但是有2个例外： 1. sizeof(数组名) - 数组名表示整个数组，计算的是整个数组的大小，单位是字节 2. &数组名 - 数组名也表示整个数组，取出的是整个数组的地址， 除了这个2个例外，你见到的所有的数组名都表示首元素的地址 strlen 是库函数 strlen 求字符串长度的，计算的是字符串中‘\0’之前出现的字符的个数统计到\0为止,如果没有看到‘\0’，会继续往后找
【c语言】指针经典笔试题
m0_71659028的博客
09-10 652
本文讲解了笔试中经典的笔试题，耐心观看，必有收获
C语言实例&网上参考的笔试题（部分）
woshizuopie的博客
12-25 877
第9、10题需要再看。 1.输出九九乘法口诀表 #include<stdio.h> int main(){ int i = 0; //外层循环变量，控制行 int j = 0; //内层循环变量，控制列 for(i=1;i<=9;i++){ for(j=1;j<=i;j++){ printf("%d*%d=%d\t",j,i,i*j); } printf("\n
一文搞定sizeof笔试面试题
judith的博客
06-25 187
转自https://blog.csdn.net/stpeace/article/details/113838908 1.sizeof(基本类型) #include<iostream> #include<cstring> using namespace std; void fun1(char str[20]) { cout << sizeof(str) << endl; } void fun2(char a[10][9]) { cout &l.
c语言指针和数组笔试题解析-1
m0_58342797的博客
09-03 204
strlen（）和sizeof（）的区别 1.strlen函数：库函数，功能：求字符串的长度。 函数原型：size_t strlen ( const char * str ); 格式：strlen （字符指针表达式） 功能：计算给定字符串的（unsigned int型）长度，不包括'\0'在内 说明：返回s的长度，不包括结束符NULL。 头文件：string.h 运算时执行 2.sizeof:在 C 语言中，sizeof() 是一个判断数据类型或者表达式长度的运算符。 sizeof（）是在编
嵌入式-C语言常见面试/笔试题
热门推荐
qq_34934140的博客
03-07 1万+
【1】关键字类型题 常见的关键字有 sizeof、static、const、volatile 1、sizeof：通常与strlen做比较不同 例1：char str[] = “Hello” ; char *p = str ; int n = 10;
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、付费专栏及课程。

余额充值