sizeof()和strlen()的区别

最新推荐文章于 2024-07-27 21:21:07 发布
最新推荐文章于 2024-07-27 21:21:07 发布
阅读量986 收藏 13
点赞数 5
分类专栏： c语言 文章标签： sizeof strlen
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhao_miao/article/details/79770080
版权

sizeof:              求所分配的字节数，单位是字节；

strlen:               获取字符的个数；

几个重要的知识点： 

  • 数组名单独放在sizeof内部，数组名表示整个数组的大小；
  • &+数组名，数组名表示整个数组；&数组名，取出的是整个数组的地址；
  • 除此之外，所有的数组名都是首元素的地址；
  • 一些典型的例子：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int a[] = { 1, 2, 3, 4 };
	printf("%d\n", sizeof(a));        //16
	printf("%d\n", sizeof(a+0));      //4
	printf("%d\n", sizeof(*a));       //4
	printf("%d\n", sizeof(a+1));      //4
	printf("%d\n", sizeof(a[1]));     //4
	printf("%d\n", sizeof(&a));       //4
	printf("%d\n", sizeof(*&a));      //16
	printf("%d\n", sizeof(&a+1));     //4
	printf("%d\n", sizeof(&a[0]));    //4
	printf("%d\n", sizeof(&a[0]+1));  //4
        system("pause");
	return 0;}
  1. sizeof(a)       数组名单独放在sizeof内部，表示整个数组的大小。 整个数组4个元素，一个元素4个字节，共16个字节。
  2. sizeof(a+0)  数组名没有单独放在sizeof内部，数组名前也没有&，所以a表示首元素的地址；a+0依旧表示首元素的地址，地址为4个字节。
  3. sizeof(*a)     数组名没有单独放在sizeof内部，数组名前也没有&，所以a表示首元素的地址；*a表示首元素，int(整形）元素占4个字节。
  4. sizeof(a+1)   数组名没有单独放在sizeof内部，数组名前也没有&，所以a表示首元素的地址；a+1表示第二个元素的地址。地址占4个字节。
  5. sizeof(a[1])   a[1]表示第二个元素，int(整形）元素占4个字节。
  6. sizeof(&a)    数组名没有单独放在sizeof内部,但是数组名前有&，所以&a表示整个数组的地址。地址占4个字节。
  7. sizeof(*&a)   数组名没有单独放在sizeof内部,但是数组名前有&，所以&a表示整个数组的地址；*(&a)表示整个数组的元素。整个数组4个元素，一个元素4个字节，共16个字节。
  8. sizeof(&a+1) 数组名没有单独放在sizeof内部,但是数组名前有&,所以&a表示整个数组的地址；&a+1表示跳过整个数组的下一个元素地址。地址占4个字节
  9. sizeof(&a[0]) a[0]表示首元素，&a[0]表示首元素的地址。地址占4个字节
  10. sizeof（&a[0]+1）a[0]表示首元素，&a[0]表示首元素的地址,&a[0]+1,表示第二个元素的地址。地址占4个字节

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

 

  1. sizeof(arr)       数组名单独放在sizeof内部，表示整个数组的大小；整个数组有6个元素，每个元素1个字节，共6个字节。
  2. sizeof(arr+0)   数组名没有单独放在sizeof内部，数组名前也没有&，所以arr表示首元素的地址；arr+0也表示首元素的地址，地址占4个字节。
  3. sizeof(*arr)      数组名没有单独放在sizeof内部，数组名前也没有&，所以arr表示首元素的地址；*arr表示首元素，字符型元素占1个字节。
  4. sizeof(arr[1])   arr[1]表示第二个元素，字符型元素占1个字节。
  5. sizeof(&arr)    数组名没有单独放在sizeof内部，但数组名前有&，所以&arr表示整个数组的地址；地址占4个字节。
  6. sizeof(&arr+1) 数组名没有单独放在sizeof内部，但数组名前有&，所以&arr表示整个数组的地址；&arr+1表示跳过整个数组，下一个元素的地址；地址占4个字节。
  7. sizeof(&arr[0]+1) &arr[0]表示首元素的地址，&arr[0]+1表示第二个元素的地址；地址占4个字节。

 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	       char arr[] = { 'a','b', 'c', 'd', 'e', 'f' };
		printf("%d\n", strlen(arr));            //随机值
		printf("%d\n", strlen(arr + 0));        //随机值
		//printf("%d\n", strlen(*arr));           //error
		//printf("%d\n", strlen(arr[1]));         //error
		printf("%d\n", strlen(&arr));           //随机值
		printf("%d\n", strlen(&arr + 1));       //比第一个随机值少6
		printf("%d\n", strlen(&arr[0] + 1));    //比第一个随机值少1
	    system("pause");
	    return 0;
}

 

  1. strlen（arr）  arr表示首元素的地址，所以字符串的长度从首元素开始数，但由于没有字符串结束标志'\0';所以为随机值。
  2. strlen(arr+0)  arr表示首元素的地址，arr+0也表示首元素的地址，所以字符串的长度从首元素开始数，但由于没有字符串结束标志'\0';所以为随机值（和1的随机值相等）。
  3. strlen(*arr)    arr表示首元素的地址，*arr表示首元素‘a’,'a'的ascii值为97；即为strlen（97），但strlen()括号里面应该为地址值，所以格式错误。
  4. strlen(arr[1]）arr[1]表示第二个元素‘b’,'b'的ascii值为98；即为strlen(98),但strlen()括号里面应该为地址值；所以错误；
  5. strlen(&arr)  &arr表示数组（首元素）的地址，所以字符串的长度从首元素开始数，但由于没有字符串结束标志'\0';所以为随机值（和1的随机值相等）。
  6. strlen(&arr+1) &arr表示整个数组的地址；&arr+1表示跳过整个数组，下一个元素的地址；由于没有字符串结束标志‘\0’,所以为随机值（比1的随机值小6）。
  7. strlen(&arr[0]+1) &arr[0]表示首元素的地址，&arr[0]+1表示第二个元素的地址,由于没有字符串结束标志‘\0’,所以为随机值（比1的随机值小1）。

 

#include<stdio.h>
#include<stdlib.h>
int main()
{
	
	        char arr[] = "abcdef";
		printf("%d\n", sizeof(arr));     //7
		printf("%d\n", sizeof(arr + 0));  //4
		printf("%d\n", sizeof(*arr));     //1
		printf("%d\n", sizeof(arr[1]));   //1
		printf("%d\n", sizeof(&arr));     //4
		printf("%d\n", sizeof(&arr + 1));  //4
		printf("%d\n", sizeof(&arr[0] + 1));//4
	        system("pause");
		return 0;
}
  1. sizeof(arr)        数组名单独放在sizeof内部，表示整个数组的大小,整个数组7个元素，每个元素有1个字节，总共7个字节。
  2. sizeof（arr+0)   数组名没有单独放在sizeof内部，数组名前也没有&，所以arr表示首元素的地址；arr+0也表示首元素的地址，地址占4个字节。
  3. sizeof(*arr)      数组名没有单独放在sizeof内部，数组名前也没有&，所以arr表示首元素的地址；*arr表示首元素，字符型元素占1个字节。
  4. sizeof(arr[1])   arr[1]表示第二个元素，字符型元素占1个字节。
  5. sizeof(&arr)     数组名没有单独放在sizeof内部，数组名前有&，所以&arr表示整个数组的地址，地址占4个字节。
  6. sizeof(&arr+1) 数组名没有单独放在sizeof内部，数组名前有&，所以&arr表示整个数组的地址,&arr+1表示跳过整个数组的下一个元素的地址；地址为4个字节。
  7. sizeof(&arr[0]+1)  &arr[0]表示首元素的地址，&arr[0]+1表示第二个元素的地址；地址为4个字节。

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

 

  1. strlen（arr）  arr表示首元素的地址，所以字符串的长度从首元素开始数，为6
  2. strlen(arr+0)  arr表示首元素的地址，arr+0也表示首元素的地址，所以字符串的长度从首元素开始数，为6
  3. strlen(*arr)    arr表示首元素的地址，*arr表示首元素‘a’,'a'的ascii值为97；即为strlen（97），但strlen()括号里面应该为地址值，所以错误。
  4. strlen（arr[1]）arr[1]表示第二个元素‘b’,'b'的ascii值为98；即为strlen(98),但strlen()括号里面应该为地址值；所以错误；
  5. strlen(&arr)  &arr表示数组（首元素）的地址，所以字符串的长度从首元素开始数，为6。
  6. strlen(&arr+1) &arr表示整个数组的地址；&arr+1表示跳过整个数组，下一个元素的地址；由于没有字符串结束标志‘\0’,所以为随机值。
  7. strlen(&arr[0]+1) &arr[0]表示首元素的地址，&arr[0]+1表示第二个元素的地址,为5。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	char *p = "abcdef";
	printf("%d\n", sizeof(p));     //4
	printf("%d\n", sizeof(p+1));   //4
	printf("%d\n", sizeof(*p));     //1
	printf("%d\n", sizeof(p[0]));   //1
	printf("%d\n", sizeof(&p));     //4
	printf("%d\n", sizeof(&p + 1));  //4
	printf("%d\n", sizeof(&p[0] + 1));//4
	system("pause");
	return 0;
}
  1. sizeof(p)       p是指针变量，存放a的地址，地址为4个字节。
  2. sizeof(p+1)   p是指针变量，存放a的地址，p+1存放b的地址，地址为4个字节。
  3. sizeof(*p)      p是指针变量，存放a的地址,*p表示元素a  ，为1个字节。
  4. sizeof(p[0])    p[0]=*(p+0),表示元素a，为1个字节。
  5. sizeof(&p)    指针变量p的地址,为4个字节。
  6. sizeof(&p+1)   指向跳过p的下一个元素的地址。为4个字节
  7. sizeof(&p[0]+1)   p[0]表示元素a，&p[0]为元素a的地址，加1为b的地址，4个字节。

 

 

 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	char *p = "abcdef";
	printf("%d\n",strlen(p));     //6
	printf("%d\n", strlen(p + 1));  //5
	// printf("%d\n", strlen(*p));     //error
	// printf("%d\n", strlen(p[0]));   //error
	printf("%d\n", strlen(&p));     //随机值
	printf("%d\n", strlen(&p + 1));  //随机值
	printf("%d\n", strlen(&p[0] + 1));//5
	system("pause");
	return 0;
}
  1. strlen(p)   p为指针变量，存放a的地址，从a向后数为6。
  2. strlen(p+1)   p为指针变量，存放a的地址，p+1存放b的地址，从b向后数为5.
  3. strlen(*p)   p为指针变量，存放a的地址，*p表示元素a，元素a的ascii为97，但strlen()括号里面应该是地址，所以错误。
  4. strlen（p[1]）p[1]表示第二个元素b，b的ascii码为98，但strlen()括号里面应该是地址，所以错误。
  5. strlen（&p）p为指针变量存放a的地址，但&p表示p的地址，我们并不知道p的地址有几位，所以为随机值。
  6. strlen(&p+1) p为指针变量存放a的地址，但&p表示p的地址,&p+1表示跨过p的下一个元素地址，后面的地址是什么我们无法确定，所以为随机值。
  7. strlen(&p[0]+1)  p[0]表示a，&p[0]为a的地址，&p[0]+1表示b的地址，从b向后数为5.

二维数组

eg:  a[3][4]  表示一个三行四列的数组，数组名为a。

       我们可以把第一行的数组名当作a[0];可以把第二行的数组名当作a[1]; 可以把第三行的数组名当作a[2];

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));       //48
	printf("%d\n", sizeof(a[0][0])); //4
	printf("%d\n", sizeof(a[0]));    //16
	printf("%d\n", sizeof(a[0]+1));  //4
	printf("%d\n", sizeof(a + 1));   //4
	printf("%d\n", sizeof(&a[0] + 1));//4
	printf("%d\n", sizeof(*a));       //16
	printf("%d\n", sizeof(a[3]));   //16
        system("pause");
	return 0;
}
  1. sizeof(a)           数组名单独放在了sizeof内部，表示整个数组的大小，共12个元素，一个元素4个字节，共48个字节。
  2. sizeof(a[0][0])   a[0][0]表示a[0][0]的地址,为4个字节。
  3. sizeof(a[0])       数组名单独sizeof内部，表示整个数组的大小，4个元素，一个元素4个字节，一共16个字节。
  4. sizeof(a+1)        数组名没有单独放在sizeof内部，数组名前没有&，所以a表示首元素a[0]的地址，a+1为第二行的地址。
  5. sizeof(&a[0]+1)  数组名没有单独放在sizeof内部，数组名有&,表示数组a[0]的地址，&a[0]+1表示数组a[1]的地址。
  6. sizeof(*a)         数组名没有单独放在sizeof内部，数组名前没有&，所以a表示首元素a[0]的地址,*a表示首元素，一共4个元素，每个元素4个字节，共16个字节。
  7. sizeof(a[3])      数组名单独sizeof内部，表示整个数组的大小，4个元素，一个元素4个字节，一共16个字节。

zhao_miao
关注
专栏目录
strlen和sizeof的区别
Rinki123456的博客
07-26 515
sizeof是一个运算符，其值在编译期间就已经计算好了，其参数可以是数组、类型、对象、函数等。功能计算该参数建立的对象的最大字节由于在编译期间就发生了计算，因此sizeof只能计算非动态的对象，sizeof的返回值和传入参数的内容无关，并且其返回值是size_t类型，也就是unsignedint类型。strlen是一个函数，其值是在运行时候被计算，strlen的参数必须是char*类型功能计算遇见'\0'之前的所有字符个数。...
sizeof和strlen的区别
duxinyu的博客
05-09 5311
sizeof和strlen经常被大家拿来作对比，但是他们之间的区别还是很大的。 一、定义不同： sizeof是运算符，在头文件中typedef为unsigned int，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。 strlen是个函数，它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。 二、语法不同 strlen是函数，要在运行时才能计算。参数必须是字符型指针。当数...
Sizeof与Strlen的区别与联系
weixin_34010566的博客
12-23 303
一、sizeof    sizeof(...)是运算符，在头文件中typedef为unsigned int，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。    它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。    由于在编译时计算，因此sizeof不能用来返回动态分配的内存空间的大小。实际上，用sizeof来返回类型以及静态分配的对象、结构或数组所占的空间，返回值...
sizeof与strlen的区别，以及字节对齐
最新发布
rjszcb的博客
07-27 327
sizeof与strlen的区别，以及字节对齐。
sizeof( )和strlen( )的用法和区别
weixin_36194037的博客
03-01 669
1.sizeof( )的用法和说明： sizeof()的定义： 在 C 语言中，sizeof() 是一个判断数据类型或者表达式长度的运算符。 其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一般定义为 typedef unsigned int size_t; 在C99及以上标准中，sizeof(char)、sizeof(int)、sizeo...
sizeof()与strlen()的区别
帐前卒 专栏
04-14 1265
sizeof()用于查看变量 所占的空间。例如：sizeof(int) // 4sizeof(float)// 4sizeof(double)//8sizeof(char) //1char * p = new char[20];sizeof(p)//这里是p指针所占的空间故为4char * p = "google";sizeof(p);//这里是p指针指向字符串常量，但si
sizeof 和strlen 区别.pdf
01-12
在C语言中，`sizeof`和`strlen`是两个非常重要的工具，它们分别用于获取不同类型的大小信息。`sizeof`是一个运算符，而`strlen`是一个函数，它们有着明显的区别。 1. `sizeof`运算符： - `sizeof`在编译时计算，...
sizeof和strlen区别
12-11
`sizeof`和`strlen`的主要区别在于： 1. 计算时机：`sizeof`是编译时操作，而`strlen`是运行时函数。 2. 应用范围：`sizeof`可应用于任何类型和变量，包括基本类型、结构体、数组等；`strlen`仅适用于C风格字符串。...
sizeof与strlen区别
07-22
### sizeof与strlen的区别详解 #### 一、概述 在C/C++编程语言中，`sizeof`和`strlen`是两个非常重要的概念，它们都用于获取有关数据的信息，但各自的作用和应用场景有所不同。本文将详细介绍这两个操作符/函数的...
简述sizeof和strlen的区别
Kay_Blake的博客
08-18 828
如何快速区分strlen和sizeof
Strlen和Sizeof的区别
挪威的森林
03-05 3465
Strlen是函数，复杂度是O(n)的 Sizeof是运算符，复杂度是常数的 Sizeof的值在声明的时候就已经确定了： 如图所示，char s[100]已经说明了sizeof(s)是100，strlen会扫描一遍直到遇到’\0’为止。 但是char是字符串指针的话，输出sizeof只是这个指针的大小4个字节，指示它指向常量字符串。 值得注意的是下面这种情况，结构体中一个i...
sizeof和strlen
weixin_30437337的博客
03-03 96
char str[20]="0123456789";int a=strlen(str); /*a=10;strlen 计算字符串的长度，以\0'为字符串结束标记。int b=sizeof(str); /*b=20;sizeof 计算的则是分配的数组str[20] 所占的内存空间的大小，不受里面存储的内容影响========================================...
strlen 与sizeof()的区别
小傅同志的专栏
09-29 679
strlen(char*)函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'\0',如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'\0'停止。  　　char aa[10];cout 　　char aa[10]={'\0'}; cout 　　char aa[10]="jun"; cout 　　而sizeof()返回的是变量声明
sizeof 和 strlen 区别
02-20
sizeof和strlen是C语言中的两个函数，它们的作用和用法有所不同。 1. sizeof： sizeof是一个运算符，用于计算数据类型或变量所占用的字节数。它可以用于任何数据类型，包括基本数据类型（如int、float等）和自定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值