sizeof与strlen的区别

1、sizeof使用如下：

#include <iostream>
#include <cstdio>
#include <stdio.h>
#include <string.h>
using namespace std;

struct{
  short a1;
  short a2;
  short a3;
}A;//结构体对齐参数默认8字节，3个short类型，对齐字数2字节，总共为6

struct{
  long a1;
  short a2;
}B;//结构体对齐参数默认8字节，1个long8字节，1个short2字节，补齐16字节（64位操作系统）
   //结构体对齐参数默认8字节，1个long4字节，1个short2字节，补齐8字节（32位操作系统）

int main()
{
    char *ss1="0123456789";//ss1是一个指针，大小为定值4（32位操作系统）8（64位操作系统）
    char ss2[]="0123456789";//char 1位，总共10位，加上结束符''，共11
    char ss3[100]="0123456789";//预分配100位，字符1位，共100

    int ss4[100];//预分配100位，int类型4位，共400
    char q1[]="abc";//同上ss2，共4
    char q2[]="a
";//'
'1位，共3
    char *q3="a
";//q3是一个指针，大小为定值4（32位操作系统）8（64位操作系统）

    char *str1=(char *)malloc(100);//str1是一个指针，大小为定值4（32位操作系统）8（64位操作系统）
    void *str2=(void *)malloc(100);//str2是一个指针，大小为定值4（32位操作系统）8（64位操作系统）

    cout<<sizeof(ss1)<<" ";
    cout<<sizeof(ss2)<<" ";
    cout<<sizeof(ss3)<<" ";
    cout<<sizeof(ss4)<<" ";
    cout<<sizeof(q1)<<" ";
    cout<<sizeof(q2)<<" ";
    cout<<sizeof(q3)<<" ";
    cout<<sizeof(A)<<" ";
    cout<<sizeof(B)<<" ";
    cout<<sizeof(str1)<<" ";
    cout<<sizeof(str2)<<" "<<endl;
    return 0;
}




#include <iostream>
#include <cstdio>
#include <stdio.h>
#include <string.h>
using namespace std;

class A{};//空类，默认1个字节
class B{char d,e;};//两个char类型，2个字节
struct C{};//空结构体，默认1个字节
struct D{char b,c;};//两个char类型，2个字节
struct E{int x,y;};//两个int类型，8个字节

class F{F();~F();};//空类，1字节
class G{//sizeof计算栈中分配大小，是不会计算静态变量的全局数据区域，所以4+1字节，对齐8字节
    G();
    ~G();
    struct{int a;char c;};
public:
    static int b;//不计算
};
class H{//同上4+1+4+4，对齐16字节
    H();
    ~H();
    struct{int a;char c;};
public:
    static int b;//不计算
    int e;
private:
    int f;
};
int main()
{

    cout<<sizeof(A)<<" ";
    cout<<sizeof(B)<<" ";
    cout<<sizeof(C)<<" ";
    cout<<sizeof(D)<<" ";
    cout<<sizeof(E)<<" ";
    A *p1=new A();//p1是一个指针，大小为定值4（32位操作系统）8（64位操作系统）
    A p2;//p2属于A的对象等同于A的大小，1字节
    A *p3;//p1是一个指针，大小为定值4（32位操作系统）8（64位操作系统）
    B *p11=new B();//p1是一个指针，大小为定值4（32位操作系统）8（64位操作系统）
    B p22;////p2属于A的对象等同于A的大小，2字节
    B *p33;//p1是一个指针，大小为定值4（32位操作系统）8（64位操作系统）
    cout<<sizeof(p1)<<" ";
    cout<<sizeof(p2)<<" ";
    cout<<sizeof(p3)<<" ";
    cout<<sizeof(p11)<<" ";
    cout<<sizeof(p22)<<" ";
    cout<<sizeof(p33)<<" "<<endl;
    cout<<sizeof(F)<< " ";
    cout<<sizeof(G)<< " ";
    cout<<sizeof(H)<< " ";
    return 0;
}




#include <iostream>
#pragma pack(1)//1强制1个字节排列，2强制2个字节排列，下面输出6字节
using namespace std;

struct A{
    int a=1;
    char b='a';
};

int main()
{
    cout << sizeof(A) << endl;//强制1个字节排列，不对其，也就是说5个字节
    return 0;
}

2、sizeof使用场合
(1)、sizeof操作符的一个主要用途是与存储分配和I/O系统那样的例程通信。例如：

void *malloc(size_t __size);
size_t fread(void *p,size_t __size,size_t n,FILE *s);

(2)、用它可以看看某种类型对象在内存中所占的单元字节。例如：

void *memset(void *s,int c,sizeof(s))

(3)、在动态分配一对象时，可以让系统知道要分配多少内存。
(4)、便于一些类型的扩充。在windows中有很多结构类型就有一个专用的字段用来存放该字节大小。
(5)、由于操作数的字节数在现实时可能出现变化，建议在涉及到操作数字节时用sizeof代替常亮计算。
(6)、如果操作数是函数中的数组形参数或函数类型的参数，sizeof给出其指针的大小。

3、sizeof与strlen两者的区别如下：

(1)、siezof操作符的结果类型是size_t，它在头文件typedef为unsigned int类型。该类型保证能容纳所建立的最大对象的字节大小。
(2)、sizeof是算符，strlen是函数。
(3)、siezof可以用类型做参数，strlen只能用char*做参数，且必须是一""结尾的。sizeof还可以作为函数的参数，比如：

short f();
cout<<sizeof(f())<<endl;输出为2

(4)、数组做sizeof的参数不退化，传递给strlen就退化为指针。
(5)、大部分编程程序的时候就把sizeof计算过来，是类型或者变量的长度。这就是sizeof(x)可以用来定义数组唯独的原因：

char str[20]="0123456789";
int a=strlen(str);//a=10
int b=sizeof(str);//b=20

(6)、strlen的结果要在运行之后才能计算出来，用来计算字符串的长度，而不是类型占内存的大小。
(7)、sizeof后如果是类型必须加括号，如果是变量名可以不加括号。这是因为sizeof是个操作符而不是个函数。

cout<<sizeof 1<<endl;

(8)、当使用了一个结构体类型或变量是，sizeof返回实际的大小。当使用静态空间的数组时，sizeof返回全部数组的尺寸。sizeof操作符不能返回被动态分配的数组或外部的数组的尺寸。

struct x
{
static double s;//sizeof计算栈中分配大小，是不会计算静态变量的全局数据区域
int *p = (int*)malloc(100 *sizeof(int));//动态分配数组，计算指针长度，8字节
int *p1=new int[100];//动态分配数组，计算指针长度8字节
};

(9)、数组作为参数传给指针的是指正而不是数组，传递的是数组的首地址，如：f(char[8])、f(char[])都等价于f(char*)。在c++里传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小。如果想在函数内知道数组的大小，需要这样做：
进入函数后用memcpy将数组拷贝出来，长度由另一个形态传进去。代码如下：

fun(unsiged char *p1,int len)
{
unsigned char* buf=new unsigned char(len+1);
memcpy (buf,p1,len);
}

(10)、C++在处理数据时经常把结构变量中的成员的大小按照4或8的倍数计算，这叫数据对齐，这样可能会浪费内存，但在理论上CPU速度快乐。设置#pragma pack(n)的设定可改变对齐规则。
(11)、sizeof操作符不能用于函数类型、不完全类型或位字段。不完全类型指具有未知存储大小数据的类型数据，如未知存储大小的数组类型，未知内容的结构或联合类型、void 类型等。