如何计算对象或者类型所占的内存字节数（各种总结）

最新推荐文章于 2023-09-24 01:18:49 发布
最新推荐文章于 2023-09-24 01:18:49 发布
阅读量4.2k 收藏 1
点赞数
分类专栏： c++基础 文章标签： c++ 类 sizeof

总结一下将sizeof用于各种类型对象或类型时其结果的算法。

1、认识sizeof

sizeof是C/C++中的一个operator，其作用就是返回一个对象或者类型所占的内存字节数（byte）。返回值是size_t，在头文件stddef.h中定义。

2、用法

sizeof的用法有一下3种：

（1）sizeof(object);//即sizeof(对象)

（2）sizeof(type_name);//即sizeof(类型名，如int,char...etc)

（3）sizeof object;//即sizeof 对象

例如：

[cpp] view plain copy print ?
  1. int i;  
  2. sizeof(i);  
  3. sizeof(int);  
  4. sizeof i;  
  5. sizeof int; //error!!!  
int i;
sizeof(i);
sizeof(int);
sizeof i;
sizeof int; //error!!!

【注】：

（1）实际上sizeof计算对象的大小也是转换成对象类型来计算的，that is to say：对同类型的不同对象使用sizeof操作，得到的值是一样的。

（2）关于上面第（1）个表达式中的object，其可以延伸至一个unary-expression(一元表达式)，例如：

[cpp] view plain copy print ?
  1. sizeof(2); //相当于sizeof(int)  
  2. sizeof(2+4.55); //相当于sizeof(2.0+4.55),从而相当于sizeof(double)  
sizeof(2); //相当于sizeof(int)
sizeof(2+4.55); //相当于sizeof(2.0+4.55),从而相当于sizeof(double)

（3）sizeof可以对函数调用求值，就相当于对该函数的返回值类型求sizeof。

[cpp] view plain copy print ?
  1. char foo()  
  2. {  
  3.     cout<<"foo函数被调用！"<<endl;  
  4.     return 'a';  
  5. }//函数   
  6. int foo_size;  
  7. foo_size=sizeof(foo());//相当于求sizeof(char)  
char foo()
{
	cout<<"foo函数被调用！"<<endl;
	return 'a';
}//函数
int foo_size;
foo_size=sizeof(foo());//相当于求sizeof(char)

（4）sizeof的计算发生在编译时刻，所以它可以被当作常量表达式使用。

例如：

[cpp] view plain copy print ?
  1. char ary[ sizeof( int ) * 10 ];  //ok~~~  
char ary[ sizeof( int ) * 10 ];  //ok~~~

3、各种sizeof计算

（1）基本数据类型的sizeof（C++primer中叫内置类型），如：int,char,double,float,short,long

在32位计算机中，各种内置类型所占的字节数如下：

char-------------1bytes;

short------------2bytes;

int----------------4bytes;

long--------------4bytes;

float--------------4bytes;

double-----------8bytes;

long double----8bytes;

（2）指针数据类型的sizeof

指针记录了另一个对象的地址，即指针变量是用来存放地址数据的，那么其当然等于计算机地址总线的宽度了。所以在32位计算机中，无论指针p指向何种类型的数据对象，其sizeof结果肯定为4bytes。

[cpp] view plain copy print ?
  1. char *pc="abcd";  
  2. int *pi;  
  3. string *ps;  
  4. char **ppc=&pc;  
  5. void (*ppf)();//函数指针  
  6. cout<<"sizeof(pc)="<<sizeof(pc)<<endl;  
  7. cout<<"sizeof(pi)="<<sizeof(pi)<<endl;  
  8. cout<<"sizeof(ps)="<<sizeof(ps)<<endl;  
  9. cout<<"sizeof(ppc)="<<sizeof(ppc)<<endl;  
  10. cout<<"sizeof(ppf)="<<sizeof(ppf)<<endl;//这5个结果均为4bytes  
char *pc="abcd";
int *pi;
string *ps;
char **ppc=&pc;
void (*ppf)();//函数指针
cout<<"sizeof(pc)="<<sizeof(pc)<<endl;
cout<<"sizeof(pi)="<<sizeof(pi)<<endl;
cout<<"sizeof(ps)="<<sizeof(ps)<<endl;
cout<<"sizeof(ppc)="<<sizeof(ppc)<<endl;
cout<<"sizeof(ppf)="<<sizeof(ppf)<<endl;//这5个结果均为4bytes

（3）数组类型的sizeof

数组的sizeof值等于数组所占用的内存字节数。

【切记】：有人以为sizeof（数组名）是求数组中元素的个数，这种认识是严重错误的。
例如：

[cpp] view plain copy print ?
  1. char a1[]="abcd";  
  2. int a2[3];  
  3. sizeof(a1)=5*1=5bytes;//一个char类型占1byte  
  4. sizeof(a2)=3*4=12bytes;  
char a1[]="abcd";
int a2[3];
sizeof(a1)=5*1=5bytes;//一个char类型占1byte
sizeof(a2)=3*4=12bytes;

【注】：

（1）求数组元素的两种方法

[cpp] view plain copy print ?
  1. int counts_a1=sizeof(a1)/sizeof(char);  
  2. int counts_a1=sizeof(a1)/sizeof(a1[0]);  
int counts_a1=sizeof(a1)/sizeof(char);
int counts_a1=sizeof(a1)/sizeof(a1[0]);

（2）当数组名被用作函数参数传递时，此时的数组名变蜕化成一个相应类型的指针了

[cpp] view plain copy print ?
  1. void foo3(char a3[3])   
  2. { 　　  
  3. int c3 = sizeof( a3 ); // c3 =3 　这里c3=sizeof(a3),想当于c3=sizeof(char*),故c3=4!!!　  
  4. }  
  5.   
  6. void foo4(char a4[])  
  7. { 　　  
  8. int c4 = sizeof( a4 ); // 同上,c4 =4!!!　　  
  9. }  
void foo3(char a3[3]) 
{ 　　
int c3 = sizeof( a3 ); // c3 =3 　这里c3=sizeof(a3),想当于c3=sizeof(char*),故c3=4!!!　
}

void foo4(char a4[])
{ 　　
int c4 = sizeof( a4 ); // 同上,c4 =4!!!　　
}

（4）结构体的sizeof

结构体在内存中时如何实际存储的呢？

结构体的大小不是所有成员大小的简单的相加，还需要考虑一个很重要的问题---------系统在存储结构体变量时存在一个“边界对齐”的问题。其实，这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度，VC对一些变量的起始地址做了“对齐”处理。在默认情况下，VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。编译器会按照成员列表的顺序一个接一个地给每个成员分配内存的，字节对齐的细节遵循以下3个原则：

1）结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal padding）；

2）结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）；

下面用例子来说明VC是怎样存放结构体的。例如：

Eg1：

[cpp] view plain copy print ?
  1. //结构体1   
  2. struct Mystruct1  
  3. {  
  4. double data_db;  
  5. char data_ch;  
  6. int data_i;  
  7. };  
//结构体1
struct Mystruct1
{
double data_db;
char data_ch;
int data_i;
};

分析：

为上面的结构体分配内存的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员data_db分配内存，其起始地址跟结构的起始地址相同（即data_db的偏移量为0，刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员data_ch分配内存，这时下一个可以分配的地址相对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把data_ch存放在偏移量为8的地方满足对齐方式，该成员变量占用sizeof(char)=1个字节；接下来为第三个成员type分配空间，这时下一个可以分配的地址相对于结构的起始地址的偏移量为9，不是sizeof(int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址相对于结构的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。所以整个结构的大小为：sizeof(MyStruct)=8+1+3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。

Eg2：

[cpp] view plain copy print ?
  1. //结构体2   
  2. struct Mystruct2  
  3. {  
  4. char data_ch;  
  5. double data_db;  
  6. int data_i;  
  7. };  
//结构体2
struct Mystruct2
{
char data_ch;
double data_db;
int data_i;
};

分析：

为上面的结构体分配内存的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员data_ch分配内存，其起始地址跟结构的起始地址相同（即data_ch的偏移量为0，刚好为sizeof(char)的倍数），该成员变量占用sizeof(char)=1个字节；接下来为第二个成员data_db分配内存，这时下一个可以分配的地址相对于结构的起始地址的偏移量为1，不是sizeof(double)=8的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充7个字节（这7个字节没有放什么东西），这是下一个可以分配的地址相对于结构的起始地址的偏移量变为8，是sizeof(double)=8的倍数了，所以把data_db存放在偏移量为8的地方满足对齐方式，该成员变量占用sizeof(double)=8个字节。接下来为第三个成员data_i分配空间，这时下一个可以分配的地址相对于结构的起始地址的偏移量为16，是sizeof(int)=4的倍数，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：1+7+8+4=20，不是结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以还得在第三个成员变量data_i的后面填充4个字节，使其达到24个字节，成为字节边界数的倍数。所以整个结构的大小为：sizeof(MyStruct)=1+7+8+4+4=24，其中有7+4个字节是VC自动填充的，没有放任何有意义的东西。

Eg3:

[cpp] view plain copy print ?
  1. #include <iostream>   
  2. using namespace std;  
  3.   
  4. char foo()  
  5. {  
  6.     cout<<"foo函数被调用!"<<endl;  
  7.     return 'a';  
  8. }  
  9.   
  10. int main()  
  11. {  
  12.     //内置数据类型   
  13.     int a=5;  
  14.     char b='c';  
  15.     cout<<"内置数据类型："<<endl;  
  16.     cout<<sizeof(int)<<endl;  
  17.     cout<<sizeof(a)<<endl;  
  18.     cout<<sizeof(char)<<endl;  
  19.     cout<<sizeof(b)<<endl;  
  20.   
  21.     //对指针求其大小   
  22.     cout<<"指针数据类型："<<endl;  
  23.     char *pc="abcd";  
  24.     int *pi;  
  25.     string *ps;  
  26.     char **ppc=&pc;  
  27.     void (*ppf)();//函数指针  
  28.     cout<<"sizeof(pc)="<<sizeof(pc)<<endl;  
  29.     cout<<"sizeof(pi)="<<sizeof(pi)<<endl;  
  30.     cout<<"sizeof(ps)="<<sizeof(ps)<<endl;  
  31.     cout<<"sizeof(ppc)="<<sizeof(ppc)<<endl;  
  32.     cout<<"sizeof(ppf)="<<sizeof(ppf)<<endl;  
  33.   
  34.   
  35.     //对函数调用求值   
  36.     cout<<"函数调用："<<endl;  
  37.     int foo_size;  
  38.     foo_size=sizeof(foo());  
  39.     cout<<"sizeof(foo())="<<foo_size<<endl;//函数foo()并不会被调用，sizeof对一个函数调用求值，就相当于对该函数的返回类型求sizeof, 即sizeof（char）  
  40.   
  41.   
  42.     //对结构体求值   
  43.     cout<<"对结构体类型："<<endl;  
  44.     struct ALIGN1  
  45.     {  
  46.         char a;  
  47.         int b;  
  48.         char c;  
  49.     };  
  50.       
  51.   
  52.     //调整ALIGN1中成员列表   
  53.     struct ALIGN3  
  54.     {  
  55.         int b;  
  56.         char a;  
  57.         char c;  
  58.     };  
  59.   
  60.     struct ALIGN2  
  61.     {  
  62.         double a;  
  63.         char b;  
  64.         int c;  
  65.     };  
  66.   
  67.     //再举一个例子   
  68.     //结构体1   
  69.     struct Mystruct1  
  70.     {  
  71.         double data_db;  
  72.         char data_ch;  
  73.         int data_i;  
  74.   
  75.     };  
  76.     //结构体2   
  77.     struct Mystruct2  
  78.     {  
  79.         char data_ch;  
  80.         double data_db;  
  81.         int data_i;  
  82.     };  
  83.   
  84.   
  85.   
  86.     cout<<"struct1的大小："<<endl;  
  87.     cout<<sizeof(ALIGN1)<<endl;  
  88.     cout<<"a的偏移量："<<offsetof(ALIGN1,a)<<endl;  
  89.     cout<<"b的偏移量："<<offsetof(ALIGN1,b)<<endl;  
  90.     cout<<"c的偏移量："<<offsetof(ALIGN1,c)<<endl;  
  91.   
  92.     cout<<"struct2的大小："<<endl;  
  93.     cout<<sizeof(ALIGN2)<<endl;  
  94.   
  95.   
  96.     cout<<"struct3的大小："<<endl;  
  97.     cout<<sizeof(ALIGN3)<<endl;  
  98.     cout<<"a的偏移量："<<offsetof(ALIGN3,a)<<endl;  
  99.     cout<<"b的偏移量："<<offsetof(ALIGN3,b)<<endl;  
  100.     cout<<"c的偏移量："<<offsetof(ALIGN3,c)<<endl;  
  101.   
  102.     //输出Mystruct1和Mystruct2的大小   
  103.     cout<<"sizeof(Mystruct1)="<<sizeof(Mystruct1)<<endl;  
  104.     cout<<"sizeof(Mystruct2)="<<sizeof(Mystruct2)<<endl;  
  105.   
  106.     //查看Mystruct1和Mystruct2中变量的（相对于结构体的起始地址）偏移量  
  107.     cout<<"Mystruct1_data_db的偏移量="<<offsetof(Mystruct1,data_db)<<endl;  
  108.     cout<<"Mystruct1_data_ch的偏移量="<<offsetof(Mystruct1,data_ch)<<endl;  
  109.     cout<<"Mystruct1_data_i的偏移量="<<offsetof(Mystruct1,data_i)<<endl;  
  110.   
  111.     cout<<"Mystruct2_data_db的偏移量="<<offsetof(Mystruct2,data_db)<<endl;  
  112.     cout<<"Mystruct2_data_ch的偏移量="<<offsetof(Mystruct2,data_ch)<<endl;  
  113.     cout<<"Mystruct2_data_i的偏移量="<<offsetof(Mystruct2,data_i)<<endl;  
  114.   
  115.   
  116.   
  117.     return 0;  
  118. }  
#include <iostream>
using namespace std;

char foo()
{
	cout<<"foo函数被调用!"<<endl;
	return 'a';
}

int main()
{
	//内置数据类型
	int a=5;
	char b='c';
	cout<<"内置数据类型："<<endl;
	cout<<sizeof(int)<<endl;
	cout<<sizeof(a)<<endl;
	cout<<sizeof(char)<<endl;
	cout<<sizeof(b)<<endl;

	//对指针求其大小
	cout<<"指针数据类型："<<endl;
	char *pc="abcd";
	int *pi;
	string *ps;
	char **ppc=&pc;
	void (*ppf)();//函数指针
	cout<<"sizeof(pc)="<<sizeof(pc)<<endl;
	cout<<"sizeof(pi)="<<sizeof(pi)<<endl;
	cout<<"sizeof(ps)="<<sizeof(ps)<<endl;
	cout<<"sizeof(ppc)="<<sizeof(ppc)<<endl;
	cout<<"sizeof(ppf)="<<sizeof(ppf)<<endl;


	//对函数调用求值
	cout<<"函数调用："<<endl;
	int foo_size;
	foo_size=sizeof(foo());
	cout<<"sizeof(foo())="<<foo_size<<endl;//函数foo()并不会被调用，sizeof对一个函数调用求值，就相当于对该函数的返回类型求sizeof, 即sizeof（char）


	//对结构体求值
	cout<<"对结构体类型："<<endl;
	struct ALIGN1
	{
		char a;
		int b;
		char c;
	};
	

	//调整ALIGN1中成员列表
	struct ALIGN3
	{
		int b;
		char a;
		char c;
	};

	struct ALIGN2
	{
		double a;
		char b;
		int c;
	};

	//再举一个例子
	//结构体1
	struct Mystruct1
	{
		double data_db;
		char data_ch;
		int data_i;

	};
	//结构体2
	struct Mystruct2
	{
		char data_ch;
		double data_db;
		int data_i;
	};



	cout<<"struct1的大小："<<endl;
	cout<<sizeof(ALIGN1)<<endl;
	cout<<"a的偏移量："<<offsetof(ALIGN1,a)<<endl;
	cout<<"b的偏移量："<<offsetof(ALIGN1,b)<<endl;
	cout<<"c的偏移量："<<offsetof(ALIGN1,c)<<endl;

	cout<<"struct2的大小："<<endl;
	cout<<sizeof(ALIGN2)<<endl;


	cout<<"struct3的大小："<<endl;
	cout<<sizeof(ALIGN3)<<endl;
	cout<<"a的偏移量："<<offsetof(ALIGN3,a)<<endl;
	cout<<"b的偏移量："<<offsetof(ALIGN3,b)<<endl;
	cout<<"c的偏移量："<<offsetof(ALIGN3,c)<<endl;

	//输出Mystruct1和Mystruct2的大小
	cout<<"sizeof(Mystruct1)="<<sizeof(Mystruct1)<<endl;
	cout<<"sizeof(Mystruct2)="<<sizeof(Mystruct2)<<endl;

	//查看Mystruct1和Mystruct2中变量的（相对于结构体的起始地址）偏移量
	cout<<"Mystruct1_data_db的偏移量="<<offsetof(Mystruct1,data_db)<<endl;
	cout<<"Mystruct1_data_ch的偏移量="<<offsetof(Mystruct1,data_ch)<<endl;
	cout<<"Mystruct1_data_i的偏移量="<<offsetof(Mystruct1,data_i)<<endl;

	cout<<"Mystruct2_data_db的偏移量="<<offsetof(Mystruct2,data_db)<<endl;
	cout<<"Mystruct2_data_ch的偏移量="<<offsetof(Mystruct2,data_ch)<<endl;
	cout<<"Mystruct2_data_i的偏移量="<<offsetof(Mystruct2,data_i)<<endl;



	return 0;
}


 

以上都是一些简单的东西，但是要是时间久了，这些细枝末节就很可能被大家遗忘了，而且这些东西也是笔试中经常光顾的问题。小弟暂且将小文作为乍到CSDN的第一篇文章，花了2个多小时整理出来，愿与君共勉。

SHForWork
关注
专栏目录
详解如何计算字符中的字节数
曹定栓的博客
08-10 2370
关于字符编码，有三个核心概念： 字符集(Character Set)，可以说是一个抽象概念，字符的合集。 码位(Code Point),也叫码点，将抽象的字符集中的每一个字符映射到一个整数。Unicode(即UCS-2或UCS-4)就是属于这一层的概念。它完全是数学的抽象，和计算机没有任何关系。 字符编码(Encoding)，按照某种编码规则用二进制来表示一个字符。UTF-8，UTF-16等都是属于这一层的概念。
结构体所占内存的字节数如何计算？
热门推荐
xia__mu的博客
08-22 1万+
我们知道，为了提高内存寻址的效率，很多处理器体系结构为特定的数据类型引入 了特殊的内存对齐需求。不同的系统和编译器，内存对齐的方式有所不同，为了满足 处理器的对齐要求，可能会在较小的成员后加入补位，从而导致结构体实际所占内存的 字节数比我们想象的多出一些字节。 下面从4个方面进行阐述： （1）结构体只包含基本数据类型； （2）结构体含有复合数据类型（例如包含strcut uni...
C语言结构体所占用的字节数如何计算
biao2488890051的博客
05-05 8385
看到个写得比较好的博文，转给大家看看 格式一：　　 1 2 3 4 5 6 01.structtagPhone 02.{ 03.charA; 04.intB; 05.shortC; 06.}Phone; 　　格式二： ...
各种数据类型的字节数
Michael
01-20 790
注意： 在这里是 64位， 所以 long 型是 8字节， 但是在32位的机器设备上 long型数据为 4字节。
如何计算对象或者类型所占的内存字节数
wang82563574的专栏
02-29 1626
总结一下将sizeof用于各种类型对象或类型时其结果的算法。 1、认识sizeof sizeof是C/C++中的一个operator，其作用就是返回一个对象或者类型所占的内存字节数（byte）。返回值是size_t，在头文件stddef.h中定义。 2、用法 sizeof的用法有一下3种： （1）sizeof(object);//即sizeof(对象) （2）sizeof(type
【JAVA内存】如何计算一个Java对象占用的字节数
虚极静笃
09-23 1461
原文地址:点击打开链接 ,翻译有出入之处，请以原文为准 本文中，我们讨论一个问题：如何计算(或者说，估算)一个Java对象占用的内存数量？ 通常，我们谈论的堆内存使用的前提是以“一般情况”为背景的。不包括下面两种情形：   某些情况下，JVM根本就没有把Object放入堆中。例如：原则上讲，一个小的thread-local对象存在于栈中，而不是在堆中。被Object占用内存
JAVA内存使用--如何计算一个Java对象占用的字节数
kobejayandy的专栏
11-17 1093
本文中，我们讨论一个问题：如何计算(或者说，估算)一个Java对象占用的内存数量？ 通常，我们谈论的堆内存使用的前提是以“一般情况”为背景的。不包括下面两种情形： 某些情况下，JVM根本就没有把Object放入堆中。例如：原则上讲，一个小的thread-local对象存在于栈中，而不是在堆中。被Object占用内存的大小依赖于Object的当前状态。例如：Object的同步锁是否生效，
JAVA对象所占内存大小计算例子
11-14
本文将深入探讨如何计算Java对象所占内存，并通过提供的代码示例进行详细解析。 首先，我们需要理解Java对象内存占用的基本原理。每个Java对象都由三部分组成：对象头（Object Header）、实例数据（Instance Data）...
基本数据类型所占字节数
幺玲的博客
04-11 1万+
C标准中并没有具体给出规定那个基本类型应该是多少字节数，具体与机器、OS、编译器有关，比如同样是在32bits的操作系统系，VC++的编译器下int类型为占4个字节；而tuborC下则是2个字节。所以int，long int，short int的宽度都可能随编译器而异。但有几条铁定的原则（ANSI/ISO制订的）：sizeof(short int)&lt;=sizeof(int)sizeof(in...
如何正确计算文本所占字节数
旭日东升
05-13 1万+
计算文本（字符串）所占字节数，大家第一个想到的应该就是String类的getBytes()方法，该方法返回的是字符串对应的字节数组，再计算数组的length就能够得到字符串所占字节数。例如： public static void main(String []args)  { // 运行结果：12 System.out.println("旭日东升".getBytes().lengt
求各种常用数据类型的字节数
qq_44896572的博客
06-05 485
使用求字节数运算符sizeof()（注意sizeof（）是运算符不是函数）求char型，int型，float型，double型等常用数据类型的字节数。 #include<stdio.h> #include<stdlib.h> int main() { printf("char:%d\n", sizeof(char)); printf("short:%d\n", size...
各数据类型存储的字节数
syz201558503103的博客
08-02 1万+
1.字节：byte：用来计量存储容量的一种计量单位；位：bit 2.一个字节等于8位 1byte = 8bit 1字节=8位 1k=1024字节=2^10 1m=1024k 1g=1024m 3.java里 整型： byte:1个字节 8位 -128~127 short ：2个字节 16位 (-2^15~2^15-1) int ：4个字节 32位 (-2^31~2^31-1) long：8个字节 64位 (-2^63~2^63-1) 浮点型： floa...
各种数据类型占字节数
yubing841026的专栏
10-25 2941
int占多少位的一点看法 int的字节长度是由CPU和操作系统编译器共同决定的，一般情况下，主要是由操作系统决定，比如，你在64位AMD的机器上安装的是32位操作系统，那么，int默认是32位的；如果是64位操作系统，64位操作系统分为两种，1种是int为32位long为64位，2种int long均为64位。之所以说int同时也与编译器有关，编译器完全可以在32位系统模拟64位整数
数据类型对应的字节数
kyle1314608的博客
01-26 5565
1、32位和64位CPU CPU一次处理数据的能力都是2的倍数，所以有8位、16位、32位、64位CPU。 (1) 64位CPU拥有更大的寻址能力，最大支持到16GB内存，而32位CPU只支持4G内存。 (2) 64位CPU一次可提取64位数据，比32位提高了一倍，理论上性能会提升1倍。 2、程序运行平台 平台是由 CPU+OS+Compiler 构成，因为： 64位CPU上可以运行32位OS。例如，x64 CPU上运行Windows XP。 32位OS上可以有16/32位编译器。例如，Windows XP
C语言中数组所占字节的计算方法
最新发布
CyberWarpX的博客
09-24 2751
请注意，上述示例代码中的sizeof(int)是根据int类型在特定系统上占用的字节数来计算的。如果需要计算其他数据类型的数组所占字节数，只需将上述代码中的int替换为相应的数据类型即可。总结起来，C语言中数组所占字节数可以通过将元素类型的字节数乘以数组大小来计算。在这篇文章中，我们将讨论如何计算C语言中数组所占用的字节数。在上述公式中，元素类型的字节数指的是数组中每个元素所占用的字节数。C语言中的数组是通过指定数组元素类型和数组大小来声明的。在上面的示例代码中，我们首先声明了一个包含5个整型元素的数组。
常用数据类型占内存字节数
不积跬步，无以至千里；不积小流，无以成江海。
04-21 3668
常用基本数据类型占内存的字节数
常见数据类型及占用的字节数
weixin_44003177的博客
06-03 699
学习目标： 提示：这里可以添加学习目标 例如：一周掌握 Java 入门知识 学习内容： 提示：这里可以添加要学的内容 例如： 1、 搭建 Java 开发环境 2、 掌握 Java 基本语法 3、 掌握条件语句 4、 掌握循环语句 学习时间： 提示：这里可以添加计划学习的时间 例如： 1、 周一至周五晚上 7 点—晚上9点 2、 周六上午 9 点-上午 11 点 3、 周日下午 3 点-下午 6 点 学习产出： 提示：这里统计学习计划的总量 例如： 1、 技术笔记 2 遍 2、CSDN 技术博客
c语言常用数据类型所占用的字节数
weixin_33795806的博客
12-25 567
一、数据类型所占用字节数与机器字长与编译器有关，遵循的几条规律如下： sizeof(short int )<=sizeof(int) sizeof(int)<=sizeof(long int) short int 至少应为16位（2个字节） long in 至少应为32位（4个字节） 二、常见数据类型字节数 　　　　　　　　 16位编译器：char *(指...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值