sizeof和strlen求取数组&指针之辨析

这篇具有很好参考价值的文章主要介绍了sizeof和strlen求取数组&指针之辨析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一维数组中sizeof Vs  strlen

整型数组sizeof

字符数组

sizeof

strlen 

字符串数组

sizeof

strlen 

字符串的指针char *p

sizeof

strlen 

二维数组中sizeof 

总结


今天主要来讲题目主要是数组&指针辨析题和笔试题。🆗最近心情有点焦虑。大家一定专注眼前的事情,别太焦虑。

一维数组中sizeof Vs  strlen

数组名:就是数组首元素的地址,但是有2个例外。

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

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

int arr[5] ={1,2,3,4,5};

sizeof(arr)时,arr指的是整个数组,20字节。

&arr时,arr指的是整个数组的地址。

关于strlen和sizeof

  • sizeof

sizeof是操作符。
sizeof计算的占用内存的大小,单位是字节。
计算字符串是包括\0和\0之前的出现的字符个数。
计算字符是字符的个数。
sizeof计算的对象是什么类型都行。

  • strlen

strlen是库函数。
strlen是统计字符串长度的。
strlen遇到\0才停止计算。
strlen只能针对字符串,计算字符串是不包括\0。
strlen计算字符时,遇不到\0,所以随机值。
strlen是不能计算整形和字符数组的长度的,因为遇到\0才停止。

  • 注意
  • strlen求字符串长度时,统计的是在字符串\0之前的出现的字符个数
  • sizeof求字符串长度时,统计的是包括\0和\0之前的出现的字符个数
  • 必须传地址给strlen,而传合法写法给sizeof均可

整型数组sizeof

//一维数组
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("%d\n",sizeof(a[1]));
printf("%d\n",sizeof(&a));
printf("%d\n",sizeof(*&a));
printf("%d\n",sizeof(&a+1));
printf("%d\n",sizeof(&a[0]));
printf("%d\n",sizeof(&a[0]+1))
#include<stdio.h>
int main()
{
	//一维数组
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//✔
	//sizeof(数组名)表示整个数组,数组名a单独放在sizeof内部,计算的是整个数组的大小单位是字节,16字节
	//4个元素,每个元素是int类型(4个字节),16个字节
	//16
	printf("%d\n", sizeof(a + 0));
	//sizof(a+0),数组名a并非单独放在sizeof内部,也没有&,a表示数组首元素的地址,+0还是首元素的地址,地址无论何种类型,大小都是4/8个字节
	//4/8字节
	printf("%d\n", sizeof(*a));
	//sizeof(*a),数组名a并非单独放在sizeof内部,也没有&,a表示数组首元素的地址,*a表示解引用首元素的地址即找到第一个元素,就是1,一个整型元素的大小就是4个字节。
	//4字节
	//*a==*(a+0)==a[0]
	printf("%d ", sizeof(a + 1));//地址++和*地址++✔
	//sizeof(a+1),数组名a并非单独放在sizeof内部,也没有&,a表示首元素的地址,a+1表示第二个元素的地址,地址无论是何种类型,大小都是4/8个字节
	//4/8个字节--8个字节(64位)
	//a+1 == &a[1] 是第二个元素的地址
	//指向哪里?
	printf("%d\n", sizeof(*a + 1));
	//*a是首元素地址解引用为首元素,+1也好,++也罢。都只是往后移动一位4个字节,并没有说1+1=2 赋值这样,计算第二个元素的地址
	//4个字节
	printf("%d\n", sizeof(a[1]));
	//sizeof(a[1]),a[1]下标引用操作符,数组的下标从0开始,所以a[1]指的是第二个元素2,一个整型元素的大小是4个字节
	//4个字节
	printf("%d\n", sizeof(&a));//✔
	//sizeof(&a),a表示整个数组,&a就是把整个数组的地址都取出来,无论怎样还是表示地址,地址无论是何种类型,大小都是4/8个字节
	//4/8个字节
	//数组的地址 和 数组首元素的地址 的本质区别是类型的区别 并非大小的区别
	//a --- int* --指针--          int*p =a;解引用访问的是一个整型的大小
	//&a --- int(*)[4]--指针数组--       int*p[4]= &a;解引用访问的是一个数组的大小
	//但是对于p来说,都是存放一个地址,数组首元素的地址也好,整个数组的地址也好,都是一个地址,大小都是4/8个字节
	printf("%d\n", sizeof(*&a));
	//sizeof(*&a),a表示整个数组,&a就是把整个数组的地址都取出来,*&a就是把整个数组的地址都解引用,表示整个数组的元素,16个字节
	//16字节
	//*和&抵消了
	printf("%d\n", sizeof(&a + 1));//✔
	//sizeof(&a+1),a表示整个数组的元素,&a就是把整个数组的地址都取出来,+1就是跳过一整个a数组的元素,指向跳过后的地址处,
	//无论怎样还是表示地址,地址无论是何种类型,大小都是4/8个字节
	//4/8个字节
	//指向哪里?
	printf("%d\n", sizeof(&a[0]));
	//sizeof(&a[0]),操作符的优先级a先和[],下标引操作符结合,得到元素1;再和&结合,得到1的地址。也就是首元素的地址。
	//无论怎样还是表示地址,地址无论是何种类型,大小都是4/8个字节
	//4/8个字节
	printf("%d\n", sizeof(&a[0] + 1));
	//sizeof(&a[0]+1),同上,得到首元素地址,+1得到第二个元素的地址。
	//无论怎样还是表示地址,地址无论是何种类型,大小都是4/8个字节
	//4/8个字节
	//&a[1]
	//&a[0]+1
	//a+1
	return 0;
}
  • sizeof(数组名),数组名表示整个数组,计算的是整个数组的大小
  • &数组名,数组名表示整个数组的地址
  • 除了以上两种情况,其他时候的数组名都是首元素的地址
    printf("%d\n", sizeof(a));//16字节
    printf("%d\n", sizeof(&a));//4/8个字节
  •  不要夹在门缝里看地址,无论是何种类型的地址,char* int* double*等都是4/8个字节
  •  在32位的平台下,4个字节。
  •  在64位的平台下,8给字节。
    	printf("%d\n", sizeof(&a));
        printf("%d\n", sizeof(a + 0));
  •  关于*p++和p++,也就是地址++和数组元素++
  •  关于地址++和数组元素++,注意数组元素++,并不是在元素本生数值上+1,也没有赋值。
  •  对于字符串的逆置的还可以回顾一下,right++和left++,以及赋值和改变的问题。
  •  关于数组名++和&数组名++所指向的位置见下图                                                                    我们需要注意的是地址++取决于指针的类型
        printf("%d ", sizeof(a + 1));
    	printf("%d\n", sizeof(*a + 1));
    	printf("%d\n", sizeof(&a + 1));//✔

    sizeof和strlen求取数组&指针之辨析,进阶C语言,c语言

字符数组

——字符数组是没有\0

#include<stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));

	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));
	return 0;
}

sizeof

#include<stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };//6
	printf("%d\n", sizeof(arr));//✔
	//sizeof(arr),数组名arr单独放在sizeof内部,指的是整个数组,计算的是整个数组的元素,6个字节
	printf("%d\n", sizeof(arr + 0));//✔
	//sizeof(arr+0),arr指的是首元素地址,+0还是首元素地址,地址无论何种类型,大小就是4/8个字节
	//arr是首元素的地址 == &arr[0].是地址就是4/8个字节
	//char*
	//指针变量的大小和类型无关,不管什么类型的指针变量,大小都是4/8个字节
	//指针变量是用来存放地址的,地址存放需要多大空间,指针变量的大小就是几个字节。
	//32位环境下,地址是32个二进制,需要4个字节,所以指针变量的大小就是几个字节
	//32位环境下,地址是64个二进制,需要8个字节,所以指针变量的大小就是几个字节
	//🆗🆗请不要在门缝里看指针,把指针看扁了。
	printf("%d\n", sizeof(*arr));
	//sizeof(*arr),arr指的是首元素地址,*arr是数组的第一个元素,1个字节
	printf("%d\n", sizeof(arr[1]));
	//数组第2个元素,数组的下标从0开始,1个字节
	printf("%d\n", sizeof(&arr));//✔
	//&arr是数组的地址,指的是整个数组的地址,数组指针,char(*p)[6]=地址无论何种类型,大小就是4/8个字节
	printf("%d\n", sizeof(&arr + 1));
	//&arr+1 是跳过数组后的地址,地址无论何种类型,大小就是4/8个字节
	printf("%d\n", sizeof(&arr[0] + 1));
	//第二个元素的地址,地址无论何种类型,大小就是4/8个字节
	return 0;
}
  • 指针变量的大小和类型无关,不管什么类型的指针变量,大小都是4/8个字节。
  • 指针变量的计算和类型有关。
  • 指针变量是用来存放地址的,地址存放需要多大空间,指针变量的大小就是几个字节。   
  • 32位环境下,地址是32个二进制,需要4个字节,所以指针变量的大小就是几个字节。
  • 32位环境下,地址是64个二进制,需要8个字节,所以指针变量的大小就是几个字节。

strlen 

 我们在模拟实现strlen的功能时,写道size_t my_strlen(const char* str)                                            所以strlen接收的是字符指针,必须传地址给strlen

#include<stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };//6个没有\0
	printf("%d\n", strlen(arr));
	//arr指的是首元素的地址
	//strlen从首元素往后计算字符的个数遇到\0停止,但是在此时内存中我们不知道\0在何处
	// 此处求出应该是随机值
	printf("%d\n", strlen(arr + 0));
	//arr+0指的是首元素的地址。
	//strlen从首元素往后计算字符的个数遇到\0停止,但是在此时内存中我们不知道\0在何处
	// 此处求出应该是随机值
	printf("%d\n", strlen(*arr));
	//*arr指的是首元素。
	//把'a'的ascll码值97 传给strlen,因为strlen只接受地址。
	//所以站在strlen的角度上,认为97是一个地址,是非法地址,直接访问发生非法访问,所以会报错。err
	printf("%d\n", strlen(arr[1]));
	//arr[1]是首元素  'b'-98
	//同上err
	printf("%d\n", strlen(&arr));
	//&arr是整个数组的地址,数值上和首元素地址一样。
	//所以,strlen从首元素往后计算字符的个数遇到\0停止,但是在此时内存中我们不知道\0在何处
	// 此处求出应该是随机值
	printf("%d\n", strlen(&arr + 1));
	//&arr+1,整个数组的地址+1,跳过整个数组,指向跳过整个数组之后的元素
	// 整个数组的地址是字符数组指针类型,	// 而我们的strlen接收的是字符指针类型
	// char(*)[6]                              const char*
	//所以这里会发生类型转化

	//那我们更加不知道在内存何处会遇到\0,所以随机值
	printf("%d\n", strlen(&arr[0] + 1));
	//&arr[0]+1,首元素地址+1,即指向第二个元素的地址。
	//所以,strlen从第二个元素往后计算字符的个数遇到\0停止,但是在此时内存中我们不知道\0在何处
	// 此处求出应该是随机值
	return 0;
}
  • strlen所接受的数据,站在strlen的角度上会全部当作地址
  • strlen所接收的地址,是const char* 字符指针类型的,当其他类型传入时,会发生类型转换
  • arr+1和&arr+1在内存中所指向的空间内存分布是怎样的。要清晰的知道。 

sizeof和strlen求取数组&指针之辨析,进阶C语言,c语言

字符串数组

——字符串数组有隐藏的\0

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));
	return 0;
}
#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));
	return 0;
}

sizeof

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));//7
	//计算的是整个数组的大小包括\0
	printf("%d\n", sizeof(arr + 0));//4/8
	//sizeof计算的是一个变量所占空间的大小
	//计算的是首元素地址的大小4/8
	printf("%d\n", sizeof(*arr));//1
	//计算的是首元素的大小1
	printf("%d\n", sizeof(arr[1]));//1
	//计算的是第二个元素的大小
	printf("%d\n", sizeof(&arr));//4/8
	//计算整个数组的地址4/8
	printf("%d\n", sizeof(&arr + 1));//4/8
	//计算跳过整个数组后指向的地址4/8
	printf("%d\n", sizeof(&arr[0] + 1));//4/8
    printf("%d\n", sizeof(arr + 1));
	//计算跳过首元素地址指向第二元素的地址4/8
	return 0;
}

 sizeof和strlen求取数组&指针之辨析,进阶C语言,c语言

strlen 

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));//6
	//首元素的地址往后计算直到遇到\0停止
	printf("%d\n", strlen(arr + 0));//6
	//首元素的地址往后计算直到遇到\0停止
	printf("%d\n", strlen(*arr));//'a'——97
	//err
	printf("%d\n", strlen(arr[1]));//'b'——98
	//err
	printf("%d\n", strlen(&arr));//6
	//整个数组的地址在数值上 == 首元素地址 往后计算直到遇到\0停止
	printf("%d\n", strlen(&arr + 1));//随机值
	//跳过整个数组后指向的地址,后面什么时候遇到\0未知,随机值
	printf("%d\n", strlen(&arr[0] + 1));//5
	printf("%d\n", strlen(arr + 1));//5
	//指向第二个元素的地址,往后计算直到遇到\0停止
	return 0;
}

sizeof和strlen求取数组&指针之辨析,进阶C语言,c语言

字符串的指针char *p

在这之前可以回顾一下字符指针

C语言之指针进阶篇(1)_唐棣棣的博客-CSDN博客

#include<stdio.h>
int main()
{
	char* p = "abcdef";
	printf("%d\n", sizeof(p));
	printf("%d\n", sizeof(p + 1));
	printf("%d\n", sizeof(*p));
	printf("%d\n", sizeof(p[0]));
	printf("%d\n", sizeof(&p));
	printf("%d\n", sizeof(&p + 1));
	printf("%d\n", sizeof(&p[0] + 1));

	printf("%d\n", strlen(p));
	printf("%d\n", strlen(p + 1));
	printf("%d\n", strlen(*p));
	printf("%d\n", strlen(p[0]));
	printf("%d\n", strlen(&p));
	printf("%d\n", strlen(&p + 1));
	printf("%d\n", strlen(&p[0] + 1));
	return 0;
}

sizeof

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	char* p = "abcdef";
	printf("%d\n", sizeof(p));//4/8
	//p是字符指针,存放的是地址,大小是4/8
	//p指的是首元素的地址
	printf("%d\n", sizeof(arr));//7

	printf("%d\n", sizeof(p + 1));//4/8
	//p+1,计算的是第二个元素的地址,大小4/8

	printf("%d\n", sizeof(*p));//1
	//首元素'a',指针解引用,看指针的类型,char*,是访问1个字节
	printf("%d\n", sizeof(p[0]));//1

	printf("%d\n", sizeof(&p));//4/8
	printf("%d\n", sizeof(&p + 1));//4/8
	printf("%d\n", sizeof(&p[0] + 1));//4/8
	return 0;
}
  • 对指针解引用,看指针的类型,再决定访问几个字节。
  • 指针计算,看指针的类型,再决定跳过几个字节。
  • 指针的大小,无论什么类型,都是4/8个字节

 sizeof和strlen求取数组&指针之辨析,进阶C语言,c语言

strlen 

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	char* p = "abcdef";
	printf("%d\n", strlen(p));//6
	printf("%d\n", strlen(p + 1))//5
	printf("%d\n", strlen(*p));//err
	printf("%d\n", strlen(p[0]));//err
	printf("%d\n", strlen(&p));//随机值
	printf("%d\n", strlen(&p + 1));//随机值
	printf("%d\n", strlen(&p[0] + 1));//5
	return 0;
}

 sizeof和strlen求取数组&指针之辨析,进阶C语言,c语言

二维数组中sizeof 

#include<stdio.h>
int main()
{
	int a[3][4] = { 0 };
	printf("%zd\n", sizeof(a));
	printf("%zd\n", sizeof(a[0][0]));
	printf("%zd\n", sizeof(a[0]));
	printf("%zd\n", sizeof(a[0] + 1));
	printf("%zd\n", sizeof(*(a[0] + 1)));
	printf("%zd\n", sizeof(a + 1));
	printf("%zd\n", sizeof(*(a + 1)));
	printf("%zd\n", sizeof(&a[0] + 1));
	printf("%zd\n", sizeof(*(&a[0] + 1)));
	printf("%zd\n", sizeof(*a));
	printf("%zd\n", sizeof(a[3]));
	return 0;
}
//sizeof的返回值是size_t ,所以打印最好使用%zd来打印
//二维数组
#include<stdio.h>
int main()
{
	int a[3][4] = { 0 };
	printf("%zd\n", sizeof(a));//4*3*4=48
	//二维数组名 单独放在sizeof内部中,计算的是整个数组的大小,单位是字节。
	printf("%zd\n", sizeof(a[0][0]));//4
	//第一行第一列的元素,计算一个元素的大小,整型,单位字节


	printf("%zd\n", sizeof(a[0]));//16
	//第一行的数组名 a[0]单独放在sizeof内部,计算的是整个第一行的大小,4*4=16
	//a[0]就表示整个第一行这个一维数组,sizeof(a[0])计算的整个第一行这个一维数组的大小
	printf("%zd\n", sizeof(a[0] + 1));//4/8
	//第一行的数组名没有单独放在sizeof内部,也没有&,表示第一行首元素的地址
	//也就是第一行第一个元素的地址 a[0]== &a[0][0]   a[0]+1== &a[0][1]
	//+1表示第一行第二个元素的地址。
	printf("%zd\n", sizeof(*(a[0] + 1)));//4
	//*解引用,表示第二个元素



	printf("%zd\n", sizeof(a + 1));//4/8
	//a没有单独放在sizeof内部,
	// 表示二维数组首元素地址,即第一行的地址,a的类型int(*)[4]---数组指针
	// +1表示第二行的地址。
	printf("%zd\n", sizeof(*(a + 1)));//4*4=16
	//解引用,表示整个第二行的大小,整型4*4
	//*(a+1) == a[1]
	//sizeof(a[1]) --- a[1]表示第二行的数组名,单独放在sizeof内部,
    //即计算的是整个第二行的大小

	printf("%zd\n", sizeof(&a[0] + 1));//4/8
	//a[0]表示第一行的数组名,&表示第一行的地址,类型是int(*)[4],
	//+1表示第二行的地址,类型int(*)[4]
	printf("%zd\n", sizeof(*(&a[0] + 1)));//16
	//解引用,表示第二行的大小


	printf("%zd\n", sizeof(*a));//16
	//a并非单独放在sizeof内部,a表示二维数组首元素地址,即第一行的地址,
	// 解引用表示第一行的大小
	//*a == *(a+0) == a[0]

	printf("%zd\n", sizeof(a[3]));//4/8
	//与a[0]同一类型int * [4],整行的地址,4/8
	//sizeof根据表达式的类型属性来计算大小的,并不会真正访问第四行,不会越界
	//a[3]    a[0]
	//int [4]     int[4]

	return 0;
}

 sizeof和strlen求取数组&指针之辨析,进阶C语言,c语言

总结

一维数组  int arr[7]={0};          二维数组      int arr[3][4]={0};

  • 数组名单独放在sizeof内部 表示是一个数组(数组元素个数✖数组元素类型所占空间大小) 
  • &数组名 取出的是一整个数组的地址(数值上与首元素地址相同 ,+1之后可看出差别)
  • 一维数组数组名arr,先判断是否单独放在sizeof内部&数组名。除了以上情况都是首元素地址
  • 二维数组数组名arr/arr[0]/arr[1]/arr[2],同上
  • 二维数组内存中连续存储(实际图),数组的数组,找行和列时下标从0开始(脑中图)
  • 写法arr[2] = *(arr+2)

指针

  • 对指针解引用,看指针的类型,再决定访问几个字节。
  • 指针计算,看指针的类型,再决定跳过几个字节。
  • 指针的大小,无论什么类型,都是4/8个字节

 字符和字符串数组

  • 字符数组里没有\0  字符串数组里有隐藏的\0 

sizeof和strlen

  • sizeof

sizeof是操作符。
sizeof计算的占用内存的大小,单位是字节。
计算字符串是包括\0和\0之前的出现的字符个数。
计算字符是字符的个数。
sizeof计算的对象是什么类型都行,sizeof计算的表达式所占空间大小,根据表达式类型属性来确定数值在内存中所占空间的大小。

  • strlen

strlen是库函数。
strlen是统计字符串长度的。
strlen遇到\0才停止计算。
strlen只能针对字符串,计算字符串是不包括\0。
strlen计算字符时,遇不到\0,所以随机值。
strlen是不能计算整形和字符数组的长度的,因为遇到\0才停止。

  • 注意
  • strlen求字符串长度时,统计的是在字符串\0之前的出现的字符个数
  • sizeof求字符串长度时,统计的是包括\0和\0之前的出现的字符个数
  • 必须传地址给strlen,而传合法写法给sizeof均可。

✔✔✔✔✔最后,感谢大家的阅读,若有错误和不足,欢迎指正!上面的题目有很多相似之处,所以看懂一组,相信后面都会。少说话多做事🆗🆗

代码------→【gitee:唐棣棣 (TSQXG) - Gitee.com】

联系------→【邮箱:2784139418@qq.com】文章来源地址https://www.toymoban.com/news/detail-733450.html

到了这里,关于sizeof和strlen求取数组&指针之辨析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C语言】sizeof和strlen的区别【详解】

    目录 一.sizeof和strlen的主要区别 二.sizeof和strlen分别讲解(含例题和详解) 1.sizeof 在计算字符型数组时(例题+讲解) 计算整型数组(例题+讲解) 2.strlen 例子一(讲解): 例子二(讲解) 三.典型例题 例1 答案解析: 例2 答案解析: 1. sizeof 是 运算符 ,而 strlen 是C语言库函数

    2024年02月09日
    浏览(53)
  • C语言 strlen、length、size、sizeof的区别

    strlen 是 C 语言中的函数,用于计算字符串的长度(不包括字符串末尾的\\\'\\0\\\')。 仅适用于以 null 字符结尾的字符串,即 C-style 字符串。 返回值类型为 size_t 。 length 和 size 都是 C++ 中 string 类型的成员函数,用于返回字符串的长度。 可以适用于任何字符串类型,包括 std::strin

    2024年02月06日
    浏览(46)
  • C语言中常用的字符串函数(strlen、sizeof、sscanf、sprintf、strcpy)

      strlen即为string length,顾名思义该函数是用来求字符串长度的。在介绍strlen函数之前,我们要先介绍一下\\\"\\0\\\"这个转义字符。任何一个字符串后面都会隐藏一个\\\"\\0\\\",该转义字符是字符串结束的标志,所以我们在使用strlen函数求字符串长度时,遇到\\\"\\0\\\"时停止读取,此时\\\"\\0\\\"前的

    2024年01月18日
    浏览(54)
  • C生万物 | 火眼辨析指针数组与数组指针

    本文我们来讲讲C语言中的易混淆的 指针数组与数组指针 ✒ 首先我想问你一个问题:指针数组是一个 指针还是一个数组 呢? 好,解答一下上面的问题,对于【指针数组】来说,它是一个 数组 ,而不是指针 来看一下上面这三个数组的定义 对于 arr1 ,他是一个整型数组,它

    2023年04月17日
    浏览(34)
  • 【C语言进阶】指针数组 —— 数组指针

    🎬 鸽芷咕 : 个人主页  🔥 个人专栏 : 《C语言进阶篇》 《C语言初阶篇》 ⛺️生活的理想,就是为了理想的生活!    🌈 hello! 各位宝子们大家好啊,前面我们已经把指针大部分内容给学完了,今天就给大家带来数组指针or指针数组!    ⛳️ 很多说这俩名字不是差不

    2024年02月14日
    浏览(38)
  • 【C语言】指针进阶:字符指针&&数组指针&&函数指针

    ✨作者:@平凡的人1 ✨专栏:《C语言从0到1》 ✨一句话:凡是过往,皆为序章 ✨说明: 过去无可挽回, 未来可以改变 🌹 感谢您的点赞与关注,同时欢迎各位有空来访我的 🍁平凡舍 回想之前,我们学了 指针 的一些基础👉 指针与结构体 我们知道了指针的概念: 指针就是

    2023年04月08日
    浏览(43)
  • C语言指针(适合C语言进阶者):一道题带你深入理解数组与指针的关系

    🎈个人主页:JAMES别扣了 💕在校大学生一枚。对IT有着极其浓厚的兴趣 ✨系列专栏目前为C语言初阶、后续会更新c语言的学习方法以及c题目分享. 😍希望我的文章对大家有着不一样的帮助,欢迎大家关注我,我也会回关,大家一起交流一起互动,感谢大家的多多支持哈! 🎉

    2024年04月16日
    浏览(54)
  • strlen和sizeof的区别

    相信大多数初步了解C语言的小伙伴们,应该对strlen和sizeof都不陌生,但是在使用时总会出现或多或少的疑问,我将用这一篇博客解决困扰大家许久的问题( 仅此一篇你就会了解的透彻 ),请耐心阅读!!! 在深究strlen和sizeof的区别时,首先我们需要知道这两个函数所执行的

    2024年02月02日
    浏览(39)
  • C++中sizeof()、size()、strlen()、length()详解

    1、size 是一个 函数 ,它是在程序运行时才会计算, 用来求数组或容器中元素的个数 。 在字符串string中它与length的作用相同,只是length只能应用于string中,而不能应用于STL的容器中 2、sizeof 为 运算符 , 其结果是求对应参数的字节大小 ,它的值是在编译的时候就计算完成了

    2024年04月16日
    浏览(40)
  • C++求字符串长度————sizeof()、size()、strlen()以及length()详解

    一、区分sizeof()和strlen() 首先, sizeof() 【操作数所占空间的字节数大小】是一种c中的 基本运算符 。(是操作符,并不是函数)可以以类型、指针、数组和函数等作为参数。 它的功能是:获得保证能容纳实现所建立的最大对象的字节大小。由于在编译时计算,因此 sizeof() 不

    2024年02月02日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包