sizeof函数用法,sizeof的用法举例

sizeof函数用法,sizeof的用法举例详细介绍

本文目录一览： sizeof的用法

C语言中的用法：
sizeof (类型说明符)
sizeof 表达式
Pascal中的用法：
Var
a:array[1..10000] of longint;
Begin
Writeln(SizeOf(a));
End.
输出：40000
如果longint改为Integer，也输出（Pascal中longInt和Integer都是4字节）:40000
在 Pascal 语言中，sizeof() 是一种内存容量度量函数，功能是返回一个变量或者类型的大小（以字节为单位）；在 C 语言中，sizeof() 是一个判断数据类型或者表达式长度的运算符。
扩展资料：
sizeof与strlen的区别：
1. sizeof是运算符，strlen是函数。
2. sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。
3. 数组做sizeof的参数不退化，传递给strlen就退化为指针了。
4. 大部分编译程序在编译的时候就把sizeof计算过了是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因。
5. strlen(char*)函数求的是字符串的实际长度，直到遇到第一个'\0'，然后就返回计数值，且不包括'\0'。而sizeof()函数返回的是变量声明后所占的内存数，不是实际长度。
参考资料来源：百度百科-sizeof
sizeof，一个其貌不扬的家伙，引无数菜鸟竟折腰，小虾我当初也没少犯迷糊，秉着“
辛苦我一个，幸福千万人”的伟大思想，我决定将其尽可能详细的总结一下。
但当我总结的时候才发现，这个问题既可以简单，又可以复杂，所以本文有的地方并不
适合初学者，甚至都没有必要大作文章。但如果你想“知其然，更知其所以然”的话，
那么这篇文章对你或许有所帮助。
菜鸟我对C++的掌握尚未深入，其中不乏错误，欢迎各位指正啊
1. 定义：
sizeof是何方神圣sizeof乃C/C++中的一个操作符（operator）是也，简单的说其作
用就是返回一个对象或者类型所占的内存字节数。
MSDN上的解释为：
The sizeof keyword gives the amount of storage, in bytes, associated with a
variable or a type (including aggregate types).
This keyword returns a value of type size_t.
其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一
般定义为
typedef unsigned int size_t;
世上编译器林林总总，但作为一个规范，它们都会保证char、signed char和unsigned
char的sizeof值为1，毕竟char是我们编程能用的最小数据类型。
2. 语法：
sizeof有三种语法形式，如下：
1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( 类型 );
3) sizeof object; // sizeof 对象;
所以，
int i;
sizeof( i ); // ok
sizeof i; // ok
sizeof( int ); // ok
sizeof int; // error
既然写法3可以用写法1代替，为求形式统一以及减少我们大脑的负担，第3种写法，忘
掉它吧！
实际上，sizeof计算对象的大小也是转换成对对象类型的计算，也就是说，同种类型的
不同对象其sizeof值都是一致的。这里，对象可以进一步延伸至表达式，即sizeof可以
对一个表达式求值，编译器根据表达式的最终结果类型来确定大小，一般不会对表达式
进行计算。如：
sizeof( 2 );// 2的类型为int，所以等价于 sizeof( int );
sizeof( 2 + 3.14 ); // 3.14的类型为double，2也会被提升成double类型，所以等价
于 sizeof( double );
sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用
，我们来看一个完整的例子：
char foo()
{
printf("foo() has been called.\n");
return 'a';
}
int main()
{
size_t sz = sizeof( foo() ); // foo() 的返回值类型为char，所以sz = sizeof(
char )，foo()并不会被调用
printf("sizeof( foo() ) = %d\n", sz);
}
C99标准规定，函数、不能确定类型的表达式以及位域（bit-field）成员不能被计算s
izeof值，即下面这些写法都是错误的：
sizeof( foo );// error
void foo2() { }
sizeof( foo2() );// error
struct S
{
unsigned int f1 : 1;
unsigned int f2 : 5;
unsigned int f3 : 12;
};
sizeof( S.f1 );// error
3. sizeof的常量性
sizeof的计算发生在编译时刻，所以它可以被当作常量表达式使用，如：
char ary[ sizeof( int ) * 10 ]; // ok
最新的C99标准规定sizeof也可以在运行时刻进行计算，如下面的程序在Dev-C++中可以
正确执行：
int n;
n = 10; // n动态赋值
char ary[n]; // C99也支持数组的动态定义
printf("%d\n", sizeof(ary)); // ok. 输出10
但在没有完全实现C99标准的编译器中就行不通了，上面的代码在VC6中就通不过编译。
所以我们最好还是认为sizeof是在编译期执行的，这样不会带来错误，让程序的可移植
性强些。
4. 基本数据类型的sizeof
这里的基本数据类型指short、int、long、float、double这样的简单内置数据类型，
由于它们都是和系统相关的，所以在不同的系统下取值可能不同，这务必引起我们的注
意，尽量不要在这方面给自己程序的移植造成麻烦。
一般的，在32位编译环境中，sizeof(int)的取值为4。
5. 指针变量的sizeof
学过数据结构的你应该知道指针是一个很重要的概念，它记录了另一个对象的地址。既
然是来存放地址的，那么它当然等于计算机内部地址总线的宽度。所以在32位计算机中
，一个指针变量的返回值必定是4（注意结果是以字节为单位），可以预计，在将来的6
4位系统中指针变量的sizeof结果为8。
char* pc = "abc";
int* pi;
string* ps;
char** ppc = &pc;
void (*pf)();// 函数指针
sizeof( pc ); // 结果为4
sizeof( pi ); // 结果为4
sizeof( ps ); // 结果为4
sizeof( ppc ); // 结果为4
sizeof( pf );// 结果为4
指针变量的sizeof值与指针所指的对象没有任何关系，正是由于所有的指针变量所占内
存大小相等，所以MFC消息处理函数使用两个参数WPARAM、LPARAM就能传递各种复杂的消
息结构（使用指向结构体的指针）。
6. 数组的sizeof
数组的sizeof值等于数组所占用的内存字节数，如：
char a1[] = "abc";
int a2[3];
sizeof( a1 ); // 结果为4，字符 末尾还存在一个NULL终止符
sizeof( a2 ); // 结果为3*4=12（依赖于int）
一些朋友刚开始时把sizeof当作了求数组元素的个数，现在，你应该知道这是不对的，
那么应该怎么求数组元素的个数呢Easy，通常有下面两种写法：
int c1 = sizeof( a1 ) / sizeof( char ); // 总长度/单个元素的长度
int c2 = sizeof( a1 ) / sizeof( a1[0] ); // 总长度/第一个元素的长度
写到这里，提一问，下面的c3，c4值应该是多少呢
void foo3(char a3[3])
{
int c3 = sizeof( a3 ); // c3 ==
}
void foo4(char a4[])
{
int c4 = sizeof( a4 ); // c4 ==
}
也许当你试图回答c4的值时已经意识到c3答错了，是的，c3!=3。这里函数参数a3已不
再是数组类型，而是蜕变成指针，相当于char* a3，为什么仔细想想就不难明白，我
们调用函数foo1时，程序会在栈上分配一个大小为3的数组吗不会！数组是“传址”的
，调用者只需将实参的地址传递过去，所以a3自然为指针类型（char*），c3的值也就为
4。
7. 结构体的sizeof
这是初学者问得最多的一个问题，所以这里有必要多费点笔墨。让我们先看一个结构体
：
struct S1
{
char c;
int i;
};
问sizeof(s1)等于多少聪明的你开始思考了，char占1个字节，int占4个字节，那么
加起来就应该是5。是这样吗你在你机器上试过了吗也许你是对的，但很可能你是错
的！VC6中按默认设置得到的结果为8。
Why为什么受伤的总是我
请不要沮丧，我们来好好琢磨一下sizeof的定义——sizeof的结果等于对象或者类型所
占的内存字节数，好吧，那就让我们来看看S1的内存分配情况：
S1 s1 = { 'a', 0xFFFFFFFF };
定义上面的变量后，加上断点，运行程序，观察s1所在的内存，你发现了什么
以我的VC6.0为例，s1的地址为0x0012FF78，其数据内容如下：
0012FF78: 61 CC CC CC FF FF FF FF
发现了什么怎么中间夹杂了3个字节的CC看看MSDN上的说明：
When applied to a structure type or variable, sizeof returns the actual siz
e, which may include padding bytes inserted for alignment.
原来如此，这就是传说中的字节对齐啊！一个重要的话题出现了。
为什么需要字节对齐计算机组成原理教导我们这样有助于加快计算机的取数速度，否
则就得多花指令周期了。为此，编译器默认会对结构体进行处理（实际上其它地方的数
据变量也是如此），让宽度为2的基本数据类型（short等）都位于能被2整除的地址上，
让宽度为4的基本数据类型（int等）都位于能被4整除的地址上，以此类推。这样，两个
数中间就可能需要加入填充字节，所以整个结构体的sizeof值就增长了。
让我们交换一下S1中char与int的位置：
struct S2
{
int i;
char c;
};
看看sizeof(S2)的结果为多少，怎么还是8再看看内存，原来成员c后面仍然有3个填
充字节，这又是为什么啊别着急，下面总结规律。
字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：
1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，
如有需要编译器会在成员之间加上填充字节（internal adding）；
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最
末一个成员之后加上填充字节（trailing padding）。
对于上面的准则，有几点需要说明：
1) 前面不是说结构体成员的地址是其大小的整数倍，怎么又说到偏移量了呢因为有
了第1点存在，所以我们就可以只考虑成员的偏移量，这样思考起来简单。想想为什么。
结构体某个成员相对于结构体首地址的偏移量可以通过宏offsetof()来获得，这个宏也
在stddef.h中定义，如下：
#define offsetof(s,m) (size_t)&(((s *)0)->m)
例如，想要获得S2中c的偏移量，方法为
size_t pos = offsetof(S2, c);// pos等于4
2) 基本类型是指前面提到的像char、short、int、float、double这样的内置数据类型
，这里所说的“数据宽度”就是指其sizeof的大小。由于结构体的成员可以是复合类型
，比如另外一个结构体，所以在寻找最宽基本类型成员时，应当包括复合类型成员的子
成员，而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将
复合类型作为整体看待。
这里叙述起来有点拗口，思考起来也有点挠头，还是让我们看看例子吧（具体数值仍以
VC6为例，以后不再说明）：
struct S3
{
char c1;
S1 s;
char c2
};
S1的最宽简单成员的类型为int，S3在考虑最宽简单类型成员时是将S1“打散”看的，
所以S3的最宽简单类型为int，这样，通过S3定义的变量，其存储空间首地址需要被4整
除，整个sizeof(S3)的值也应该被4整除。
c1的偏移量为0，s的偏移量呢这时s是一个整体，它作为结构体变量也满足前面三个
准则，所以其大小为8，偏移量为4，c1与s之间便需要3个填充字节，而c2与s之间就不需
要了，所以c2的偏移量为12，算上c2的大小为13，13是不能被4整除的，这样末尾还得补
上3个填充字节。最后得到sizeof(S3)的值为16。
通过上面的叙述，我们可以得到一个公式：
结构体的大小等于最后一个成员的偏移量加上其大小再加上末尾的填充字节数目，即：
sizeof( struct ) = offsetof( last item ) + sizeof( last item ) + sizeof( tr
ailing padding )
到这里，朋友们应该对结构体的sizeof有了一个全新的认识，但不要高兴得太早，有
一个影响sizeof的重要参量还未被提及，那便是编译器的pack指令。它是用来调整结构
体对齐方式的，不同编译器名称和用法略有不同，VC6中通过#pragma pack实现，也可以
直接修改/Zp编译开关。#pragma pack的基本用法为：#pragma pack( n )，n为字节对齐
数，其取值为1、2、4、8、16，默认是8，如果这个值比结构体成员的sizeof值小，那么
该成员的偏移量应该以此值为准，即是说，结构体成员的偏移量应该取二者的最小值，
公式如下：
offsetof( item ) = min( n, sizeof( item ) )
再看示例：
#pragma pack(push) // 将当前pack设置压栈保存
#pragma pack(2)// 必须在结构体定义之前使用
struct S1
{
char c;
int i;
};
struct S3
{
char c1;
S1 s;
char c2
};
#pragma pack(pop) // 恢复先前的pack设置
计算sizeof(S1)时，min(2, sizeof(i))的值为2，所以i的偏移量为2，加上sizeof(i)
等于6，能够被2整除，所以整个S1的大小为6。
同样，对于sizeof(S3)，s的偏移量为2，c2的偏移量为8，加上sizeof(c2)等于9，不能
被2整除，添加一个填充字节，所以sizeof(S3)等于10。
现在，朋友们可以轻松的出一口气了，:)
还有一点要注意，“空结构体”（不含数据成员）的大小不为0，而是1。试想一个“不
占空间”的变量如何被取地址、两个不同的“空结构体”变量又如何得以区分呢于是
，“空结构体”变量也得被存储，这样编译器也就只能为其分配一个字节的空间用于占
位了。如下：
struct S5 { };
sizeof( S5 ); // 结果为1
8. 含位域结构体的sizeof
前面已经说过，位域成员不能单独被取sizeof值，我们这里要讨论的是含有位域的结构
体的sizeof，只是考虑到其特殊性而将其专门列了出来。
C99规定int、unsigned int和bool可以作为位域类型，但编译器几乎都对此作了扩展，
允许其它类型类型的存在。
使用位域的主要目的是压缩存储，其大致规则为：
1) 如果相邻位域字段的类型相同，且其位宽之和小于类型的sizeof大小，则后面的字
段将紧邻前一个字段存储，直到不能容纳为止；
2) 如果相邻位域字段的类型相同，但其位宽之和大于类型的sizeof大小，则后面的字
段将从新的存储单元开始，其偏移量为其类型大小的整数倍；
3) 如果相邻的位域字段的类型不同，则各编译器的具体实现有差异，VC6采取不压缩方
式，Dev-C++采取压缩方式；
4) 如果位域字段之间穿插着非位域字段，则不进行压缩；
5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。
还是让我们来看看例子。
示例1：
struct BF1
{
char f1 : 3;
char f2 : 4;
char f3 : 5;
};
其内存布局为：
|_f1__|__f2__|_|____f3___|____|
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
0 3 7 8 1316
位域类型为char，第1个字节仅能容纳下f1和f2，所以f2被压缩到第1个字节中，而f3只
能从下一个字节开始。因此sizeof(BF1)的结果为2。
示例2：
struct BF2
{
char f1 : 3;
short f2 : 4;
char f3 : 5;
};
由于相邻位域类型不同，在VC6中其sizeof为6，在Dev-C++中为2。
示例3：
struct BF3
{
char f1 : 3;
char f2;
char f3 : 5;
};
非位域字段穿插在其中，不会产生压缩，在VC6和Dev-C++中得到的大小均为3。
9. 联合体的sizeof
结构体在内存组织上是顺序式的，联合体则是重叠式，各成员共享一段内存，所以整个
联合体的sizeof也就是每个成员sizeof的最大值。结构体的成员也可以是复合类型，这
里，复合类型成员是被作为整体考虑的。
所以，下面例子中，U的sizeof值等于sizeof(s)。
union U
{
int i;
char c;
S1 s;
};
sizeof是计算对象所占的字节个数，通常用来查看变量或结构体等所占的字节个数。
比如：
int a;sizeof(a); // 计算变量a所占的字节数，等价于sizeof(int) struct{ int num; char name[]; int age;}person;sizeof(person); // 计算整个结构所占的字节总数
sizeof是计算对象所占的字节个数，通常用来查看变量或结构体等所占的字节个数。
比如：
int a;
sizeof(a); // 计算变量a所占的字节数，等价于sizeof(int)
struct
{
int num;
char name[];
int age;
}person;
sizeof(person); // 计算整个结构所占的字节总数
sizeof，一个其貌不扬的家伙，引无数菜鸟竟折腰，小虾我当初也没少犯迷糊，秉着“
辛苦我一个，幸福千万人”的伟大思想，我决定将其尽可能详细的总结一下。
但当我总结的时候才发现，这个问题既可以简单，又可以复杂，所以本文有的地方并不
适合初学者，甚至都没有必要大作文章。但如果你想“知其然，更知其所以然”的话，
那么这篇文章对你或许有所帮助。
菜鸟我对C++的掌握尚未深入，其中不乏错误，欢迎各位指正啊
1. 定义：
sizeof是何方神圣sizeof乃C/C++中的一个操作符（operator）是也，简单的说其作
用就是返回一个对象或者类型所占的内存字节数。
MSDN上的解释为：
The sizeof keyword gives the amount of storage, in bytes, associated with a
variable or a type (including aggregate types).
This keyword returns a value of type size_t.
其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一
般定义为
typedef unsigned int size_t;
世上编译器林林总总，但作为一个规范，它们都会保证char、signed char和unsigned
char的sizeof值为1，毕竟char是我们编程能用的最小数据类型。
2. 语法：
sizeof有三种语法形式，如下：
1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( 类型 );
3) sizeof object; // sizeof 对象;
所以，
int i;
sizeof( i ); // ok
sizeof i; // ok
sizeof( int ); // ok
sizeof int; // error
既然写法3可以用写法1代替，为求形式统一以及减少我们大脑的负担，第3种写法，忘
掉它吧！
实际上，sizeof计算对象的大小也是转换成对对象类型的计算，也就是说，同种类型的
不同对象其sizeof值都是一致的。这里，对象可以进一步延伸至表达式，即sizeof可以
对一个表达式求值，编译器根据表达式的最终结果类型来确定大小，一般不会对表达式
进行计算。如：
sizeof( 2 );// 2的类型为int，所以等价于 sizeof( int );
sizeof( 2 + 3.14 ); // 3.14的类型为double，2也会被提升成double类型，所以等价
于 sizeof( double );
sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用
，我们来看一个完整的例子：
char foo()
{
printf("foo() has been called.\n");
return 'a';
}
int main()
{
size_t sz = sizeof( foo() ); // foo() 的返回值类型为char，所以sz = sizeof(
char )，foo()并不会被调用
printf("sizeof( foo() ) = %d\n", sz);
}
C99标准规定，函数、不能确定类型的表达式以及位域（bit-field
在 Pascal 语言中，sizeof() 是一种内存容量度量函数，功能是返回一个变量或者类型的大小（以字节为单位）；
在 C 语言中，sizeof() 是一个判断数据类型或者表达式长度的运算符。
1、Pascal中的用法：
如果longint改为Integer，也输出（Pascal中longInt和Integer都是4字节）；
2、C语言中用法：判断数据类型长度符的关键字
sizeof (类型说明符)sizeof 表达式
扩展资料：
sizeof与strlen区别
1、strlen(char*)函数求的是字符串的实际长度，直到遇到第一个'\0'，然后就返回计数值，且不包括'\0'。而sizeof()函数返回的是变量声明后所占的内存数，不是实际长度。
sizeof(aa) 返回10 int a[10]; sizeof(a) 返回40
2、sizeof是算符，strlen是函数。
3、sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。
参考资料：百度百科——sizeof

C语言sizeof函数如何使用？

int i = sizeof(char);
printf("%d",i);
上边的程序你就可以求出char类型所占的字节数
你可以把char改成对应的数据类型，就可以求出其他数据类型占的字节数了
当参数为数组时, 实际传参会按指针处理.
即 这里的int arr[10]等效于int *arr
sizeof(arr)也就是sizeof(int *)
对于32位系统, sizeof(int*)=4
于是选A.
如果求int 型如下：
#include "stdio.h"
main()
{
printf("sizeof(int)=%d",sizeof(int));
}
如果求其他类型只需将int 转换为相应的类型 就行了
sizeof(类型名/变量名）;
printf("%d",sizeof(int));等价于int a;printf("%d",sizeof(a));
Char
偏移量必须为sizeof(char)即1的倍数
int
偏移量必须为sizeof(int)即4的倍数
float
偏移量必须为sizeof(float)即4的倍数
double
偏移量必须为sizeof(double)即8的倍数
Short
偏移量必须为sizeof(short)即2的倍数。
按说是22，24是答案吗？
（1）sizeof不是函数，它只是一个操作符（operator）。
（2）sizeof的作用是返回一个对象或者类型所占的内存字节数，它的返回值的类型是size_t类型，而size_t是在头文件stddef.h中定义的。size_t 这是一个依赖于编译系统的值，一般定义为「typedef unsigned int size_t;」，也就是无符号整型。
（3）sizeof有三种语法形式，如下：1) sizeof( object ); // sizeof( 对象 );2) sizeof( type_name ); // sizeof( 类型 );3) sizeof object; // sizeof 对象;所以，
int i;sizeof( i ); // oksizeof i; // oksizeof( int ); // oksizeof int; // error既然写法3可以用写法1代替，为求形式统一以及减少我们大脑的负担，只用写法1就行了！
（4）说回你的提问，既然sizeof的返回值是unsigned int型，那么很明显可以用 %u 、%o 、%x 来输出，这三个都是无符号整型的格式符，分别对应十进制、八进制、十六进制。
（5）而%zd是修饰符z与有符号十进制整型格式符%d组合而成的格式符，表示按 size_t 的类型来输出。那么，肯定，%zd 可以用来输出 sizeof 的返回值。
（6）而%d是按有符号整型来输出数值，所以与unsigned int的表示范围是不一样的，如果 sizeof 的返回值超出了 %d 的表示范围的话，是会输出一个不正确的数值的。
总结一下：sizeof 的返回值可以用 %u 、 %o 、 %x 、 %zd 来正常输出，而用 %d 的时候需要注意返回值是否会超出 %d （即 signed int 型）的表示范围。
另外，有的操作系统或编译器里，size_t 的类型可能是 long unsigned int 型，所以 输出 sizeof 的返回值的时候， 应该用 %lu 等。
以上，如有帮助，烦请点采纳，谢谢！

sizeof的用法举例

sizeof的用法举例
1、用于数据类型
sizeof使用形式: sizeof (type)
数据类型必须用括号括住。如sizeof (int)。
2、用于变量
sizeof使用形式: sizeof (var name) 或sizeof var name
变量名可以不用括号括住，如sizeof(var name)，sizeof va name等都是正确形式。带括号的用法更普遍，大多数程序员采用这种形式。
注意:sizeo操作符不能用于函数类型，不完全类型或位字段。不完全类型指具有未知存储大小的数据类型，如未知存储大小的数组类。
型、未知内容的结构或联合类型、void类型等。如sizeofmax)若此时变量max定义为int max0).sizeofichar ) 若此时char v定义为char char V MAX目MAX夫知，sizeofivoid都不是正确形式
五、sizeof的主要用途
1、sizeof操作符的一个主要用途是与存储分配和I/0系统那样的例程进行通信。例如:void *malloc (size t size)。
size t fread(void * ptrsize t size.size t nmemb,FILEstream).
2、sizeot的另一个的主要用途是计算数组中元素的个数。例如:
void * memset (void * s,int c,sizeof(s)) 。由于操作数的字节数在实现时可能出现变化，建议在涉及到操作数字节大小时用sizeo来代替常量计算。

sizeof是什么，有啥用？

sizeof是C语言中保留关键字，也可以认为是一种运算符，单目运算符。常见的使用方式：
int a=10;
int arr=[1,2,3];
char str[]="hello";
int len_a = sizeof(a);
int len_arr = sizeof(arr);
int len_str = sizeof(str)
printf("len_a=%d,len_arr=%d,len_str=%d\n",len_a,len_arr,len_str)
结果是：len_a=4，len_arr=12，len_str=6
扩展资料：
在 Pascal 语言中，sizeof() 是一种内存容量度量函数，功能是返回一个变量或者类型的大小（以字节为单位）。
在 C 语言中，sizeof() 是一个判断数据类型或者表达式长度的运算符。
在Pascal 语言与C语言中，对 sizeof() 的处理都是在编译阶段进行。
sizeof是C/C++中的一个操作符（operator），简单的说其作用就是返回一个对象或者类型所占的内存字节数。
MSDN上的解释为：
The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type(including aggregate types). This keyword returns a value of type size_t.
参考资料：
百度百科-sizeof

c语言里：sizeof怎样用法？

sizeof，一个其貌不扬的家伙，引无数菜鸟竟折腰，小虾我当初也没少犯迷糊，秉着“
辛苦我一个，幸福千万人”的伟大思想，我决定将其尽可能详细的总结一下。
但当我总结的时候才发现，这个问题既可以简单，又可以复杂，所以本文有的地方并不
适合初学者，甚至都没有必要大作文章。但如果你想“知其然，更知其所以然”的话，
那么这篇文章对你或许有所帮助。
菜鸟我对C++的掌握尚未深入，其中不乏错误，欢迎各位指正啊
1. 定义：
sizeof是何方神圣sizeof乃C/C++中的一个操作符（operator）是也，简单的说其作
用就是返回一个对象或者类型所占的内存字节数。
MSDN上的解释为：
The sizeof keyword gives the amount of storage, in bytes, associated with a
variable or a type (including aggregate types).
This keyword returns a value of type size_t.
其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一
般定义为
typedef unsigned int size_t;
世上编译器林林总总，但作为一个规范，它们都会保证char、signed char和unsigned
char的sizeof值为1，毕竟char是我们编程能用的最小数据类型。
2. 语法：
sizeof有三种语法形式，如下：
1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( 类型 );
3) sizeof object; // sizeof 对象;
所以，
int i;
sizeof( i ); // ok
sizeof i; // ok
sizeof( int ); // ok
sizeof int; // error
既然写法3可以用写法1代替，为求形式统一以及减少我们大脑的负担，第3种写法，忘
掉它吧！
实际上，sizeof计算对象的大小也是转换成对对象类型的计算，也就是说，同种类型的
不同对象其sizeof值都是一致的。这里，对象可以进一步延伸至表达式，即sizeof可以
对一个表达式求值，编译器根据表达式的最终结果类型来确定大小，一般不会对表达式
进行计算。如：
sizeof( 2 );// 2的类型为int，所以等价于 sizeof( int );
sizeof( 2 + 3.14 ); // 3.14的类型为double，2也会被提升成double类型，所以等价
于 sizeof( double );
sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用
，我们来看一个完整的例子：
char foo()
{
printf("foo() has been called.\n");
return 'a';
}
int main()
{
size_t sz = sizeof( foo() ); // foo() 的返回值类型为char，所以sz = sizeof(
char )，foo()并不会被调用
printf("sizeof( foo() ) = %d\n", sz);
}
C99标准规定，函数、不能确定类型的表达式以及位域（bit-field
sizeof判断数据类型或者表达式长度符；不是一个函数，字节数的计算在程序编译时进行，而不是在程序执行的过程中才计算出来。
用法：sizeof(类型说明符，数组名或表达式);
功能：计算数据空间的字节数
参考代码：
#include

using namespace std;int main(){ double* (*a)[3][6]; cout<
<sizeof(a)<<endl; a为指针 cout<<sizeof(*a)<<endl; *a为一个有3*6个指针元素的数组 cout<<sizeof(**a)<<endl; **a为数组一维的6个指针 cout<<sizeof(***a)<<endl; ***a为一维的第一个指针 cout<<sizeof(****a)<<endl; ****a为一个double变量 return 0; } *运行结果：4722448*

</sizeof(a)<

C++ 关于size()和sizeof()

sizeof（a）返回的是对象占用内存的字节数，而a.size()是string类定义的一个返回字符串大小的函数，两个是完全不一样的概念。
明确两者的概念和作用：
1、size()函数：
c++中，在获取字符串长度时，size()函数与length()函数作用相同。 除此之外，size()函数还可以获取vector类型的长度。
例如：vector < int> num(15,2) ，则：num.size() = 15。
2、sizeof()：
sizeof()运算符用来求对象所占内存空间的大小。
假设以下对象，分别使用sizeof函数：
执行输出结果：
扩展资料：
sizeof可以对函数调用求大小，并且求得的大小等于返回类型的大小，但是不执行函数体。
首先sizeof(fun(a,b))的值：其正确是4，因为用sizeof求函数调用的大小时，它得到的是函数返回类型的大小，而fun(a,b)的返回类型是int，sizeof(int)等于4。
函数的返回类型和返回值的类型是不一样的。语句：cout<
<sizeof(fun)；得不到答案，原因就在于编译通不过。
参考资料：

百度百科--sizeof()

在c++中size()和sizeof()用法说明：

1、size()是取字符串长度的，跟length()用法相同。

举例：

string str="0123456789";

cout <<"str.length()="<
<str.length()<<endl; 结果为10
cout <<"str.size()="<
<str.size()<<endl; 结果为10
为了兼容，这两个函数一样。 length()是因为沿用C语言的习惯而保留下来的，string类最初只有length()，引入STL之后，为了兼容又加入了size()，它是作为STL容器的属性存在的，便于符合STL的接口规则，以便用于STL的算法。 string类的size()/length()方法返回的是字节数，不管是否有汉字。

2、sizeof

sizeof(...)是运算符，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。

它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。由于在编译时计算，因此sizeof不能用来返回动态分配的内存空间的大小。

举例说明：

1）char* ss = "0123456789";

sizeof(ss)为4，ss是指向字符串常量的字符指针，sizeof 获得的是指针所占的空间,则为4

sizeof(*ss)为1，*ss是第一个char字符，则为1。

sizeof返回的是对象占用内存的字节数

而a.size()是string类定义的一个返回字符串大小的函数

两个是完全不一样的概念

你可以试一下

int main()

{

string a=“abcdefg”;

cout<
<sizeof(a)<<endl;
cout<
<a.size();
return 0;

}

sizeof(a)返回值还是一样的，是cstirng类占据内存的大小

而a.size()会返回字符串的长度

sizeof 是 C语言的一个运算符。功能是 求出 表达式类型 所占用的内存字节数。

size() 是 std::string 类的一个成员函数，功能是 返回string对象内维护的字符串长度。

sizeof(a) 的结果为 4，说明 string 类型的对象（占用的内存）大小为4字节

a.size() 的结果为0，说明 对象a 中维护的字符串长度为0.

我们能常在用到 sizeof 和 strlen 的时候，通常是计算字符串数组的长度

从这个例子可以看得很清楚：har str[11]="0123456789";//注意这里str大小因该大于等于11，应考虑'\0'在内，否则编译器会报错

int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度，以结束符 0x00 为字符串结束。

int b=sizeof(str); //而b=11; >>>> sizeof 计算的则是分配的数组 str[11] 所占的内存空间的大小，不受里面存储的内容改变。

打字不易，如满意，望采纳。

sizeof（a）返回的是对象占用内存的字节数，而a.size()是string类定义的一个返回字符串大小的函数，两个是完全不一样的概念。

明确两者的概念和作用：

1、size()函数：

c++中，在获取字符串长度时，size()函数与length()函数作用相同。 除此之外，size()函数还可以获取vector类型的长度。

例如：vector < int> num(15,2) ，则：num.size() = 15。

2、sizeof()：

sizeof()运算符用来求对象所占内存空间的大小。

假设以下对象，分别使用sizeof函数：

执行输出结果：

扩展资料

sizeof(...)是运算符，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。由于在编译时计算，因此sizeof不能用来返回动态分配的内存空间的大小。

size是由string vector 和bitset定义的函数，分别用于返回字符个数，元素个数和二进制位的数。string和vector的size成员函数用以返回size_type类型的值。bitset返回size_t的值。用法，例如string

string st("fddddddddgs");

cout<<"the size of"<
<st<<"is"<<st.size();
打印st中的字符个数size其实就是计算不同类型容器中的元素个数的。

参考资料：百度百科 sizeof()
</st<<"is"<<st.size();
</a.size();
</sizeof(a)<<endl;
</str.size()<
</str.length()<
</sizeof(fun)；得不到答案，原因就在于编译通不过。

c语言sizeof函数

在 Pascal 语言中，sizeof() 是一种内存容量度量函数，功能是返回一个变量或者类型的大小（以字节为单位）；在 C 语言中，sizeof() 是一个判断数据类型或者表达式长度的运算符。
%d就行了 能放下就行
（1）sizeof不是函数，它只是一个操作符（operator）。
（2）sizeof的作用是返回一个对象或者类型所占的内存字节数，它的返回值的类型是size_t类型，而size_t是在头文件stddef.h中定义的。size_t 这是一个依赖于编译系统的值，一般定义为「typedef unsigned int size_t;」，也就是无符号整型。
（3）sizeof有三种语法形式，如下：1) sizeof( object ); // sizeof( 对象 );2) sizeof( type_name ); // sizeof( 类型 );3) sizeof object; // sizeof 对象;所以，
int i;sizeof( i ); // oksizeof i; // oksizeof( int ); // oksizeof int; // error既然写法3可以用写法1代替，为求形式统一以及减少我们大脑的负担，只用写法1就行了！
（4）说回你的提问，既然sizeof的返回值是unsigned int型，那么很明显可以用 %u 、%o 、%x 来输出，这三个都是无符号整型的格式符，分别对应十进制、八进制、十六进制。
（5）而%zd是修饰符z与有符号十进制整型格式符%d组合而成的格式符，表示按 size_t 的类型来输出。那么，肯定，%zd 可以用来输出 sizeof 的返回值。
（6）而%d是按有符号整型来输出数值，所以与unsigned int的表示范围是不一样的，如果 sizeof 的返回值超出了 %d 的表示范围的话，是会输出一个不正确的数值的。
总结一下：sizeof 的返回值可以用 %u 、 %o 、 %x 、 %zd 来正常输出，而用 %d 的时候需要注意返回值是否会超出 %d （即 signed int 型）的表示范围。
另外，有的操作系统或编译器里，size_t 的类型可能是 long unsigned int 型，所以 输出 sizeof 的返回值的时候， 应该用 %lu 等。
以上，如有帮助，烦请点采纳，谢谢！

利用sizeof函数计算c语言各种数据类型所占用的空间？

在 C 语言中，可以使用 sizeof 运算符来计算不同数据类型所占用的空间大小。sizeof 运算符的语法格式如下：
sizeof(type)
其中，type 是数据类型，可以是 int、char、float、double、struct、union 等等。
下面是常见数据类型在 64 位系统中所占用的空间大小：
char：1 字节
short：2 字节
int：4 字节
long：8 字节
long long：8 字节
float：4 字节
double：8 字节
long double：16 字节
可以通过下面的代码来查看各种数据类型在你的机器上所占用的空间大小：
#include

int main() {

printf("sizeof(char) = %lu\n", sizeof(char));

printf("sizeof(short) = %lu\n", sizeof(short));

printf("sizeof(int) = %lu\n", sizeof(int));

printf("sizeof(long) = %lu\n", sizeof(long));

printf("sizeof(long long) = %lu\n", sizeof(long long));

printf("sizeof(float) = %lu\n", sizeof(float));

printf("sizeof(double) = %lu\n", sizeof(double));

printf("sizeof(long double) = %lu\n", sizeof(long double));

return 0;

}

注意，sizeof 运算符返回的是一个 size_t 类型的无符号整数，它表示数据类型所占用的字节数。

C语言sizeof函数如何使用？

C语言中的sizeof是一个很有意思的关键字，经常有人用不对，搞不清不是什么。我以前也有用错的时候，现在写一写，也算是提醒一下自己吧。反正现在来看，还在搞sizeof是什么意思，怎么用正确，还是有点搞笑，都经常用的东西，没有理解透彻，就差的太远了。
一 sizeof是什么
sizeof是C语言的一种单目操作符，如C语言的其他操作符++、--等，sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。这个操作数不好理解对吧？后面慢慢看就明白了。sizeof的返回值是size_t，在64位机器下，被定义为longunsignedint。
二sizeof如何使用
1、用于数据类型
使用形式:sizeof(type)。其中type如int、double等。例如sizeof(int)、sizeof(char*)、sizeof(double)。这个时候sizeof后面的类型必须用括号()包起来，不包起来是错误的，通过不了编译。其中sizeof(void*)在64位下是8，而sizeof(void)是1。其实，在C语言中sizeof(函数)，
如sizeof(main)，结果也是1。但是在C++中，sizeof(void)和sizeof(函数)都是非法的，通过不了编译，后面C++就不说了，现在讲C嘛。其实sizeof(函数)，sizeof(void)虽然是1，但是是不正确的使用方式。
2、用于变量
使用形式:sizeof(var)或sizeofvar。当操作基本数据类型的时候，在我64位电脑的结果如下
作用是：计算常量、变量、数据类型在内存中占用的字节数
三、用sizeof计算常量在内存中占用的字节数
sizeof(1)计算常量1在内存中占用的字节数 4
1默认的事一个10进制的整数（int）4
sizeof(2.3f);计算float类型的常量在内存中占用的字节数4
sizeof(2.3); 计算double类型的常量在内存中占用的字节数8
sizeof('a'); 计算'a'字符常量在内存中占用的字节数 1 4？