sizeof求字节以及与strlen的区别

/*
*根据以下条件进行计算:
*1、  结构体的大小等于结构体内最大成员大小的整数倍
*2、  结构体内的成员的首地址相对于结构体首地址的偏移量是其类型大小的整数倍，比如说double型成员相对于结构体的首地址的地址
*偏移量应该是8的倍数。
*/
#include<iostream>
#include<cstdlib>
using namespace std;

class AA
{
        int a;
        short b;
        int c;
        char d;
};
class BB
{
        double a;
        short b;
        int c;
        char d;
};

struct{
    short a1;
    short a2;
    short a3;
}A;

struct{
    long a1;
    short a2;
}B;

int main()
{
    cout<<sizeof(AA)<<" "<<sizeof(BB)<<endl;
    char *ss1="0123456789";
    char ss2[]="0123456790";
    char ss3[100]="0123456789";
    int ss4[100];
    char q1[]="abc";
    char q2[]="a\n";
    char *q3="a\n";
    char *str1=(char*)malloc(100);

    void *str2=(void*)malloc(100);

    cout<<sizeof(ss1)<<endl;//ss1是一个字符指针，指针的大小是一个定值，就是4
    cout<<sizeof(ss2)<<endl; //ss2是一个字符数组，这个数组最初未定大小，由具体情况填充
    cout<<sizeof(ss3)<<endl;//ss3也是一个字符数组，这个数组开始预分配100，所以它的大小一共是100位
    cout<<sizeof(ss4)<<endl;//ss4也是一个整型数组，这个数组开始预分配100，但每个整型变量所占空间是4，所以它的大小一共是400
    cout<<sizeof(q1)<<endl; //q1和ss2类似，所以是4
    cout<<sizeof(q2)<<endl;//q2里面有一个‘\n‘，算作一位，所以它的空间是3
    cout<<sizeof(q3)<<endl;//q3是一个字符指针，指针的大小是一个定值，就是4，所以sizeof(q3)是4
    cout<<sizeof(A)<<endl; //结构体的长度一定是最长的数据元素的整数倍
    cout<<sizeof(B)<<endl;
    cout<<sizeof(str1)<<endl;  //指针的长度固定是4
    cout<<sizeof(str2)<<endl;
}

#include<iostream>
#include<new>
using namespace std;

class A{};

class A2{
    char d,e;
};

class B{

};

struct C{
    char b,c;
};

struct D{
    int x,y;
};

int main()
{
    cout<<sizeof(A)<<endl;  //对于一个类而言，即便它是一个空的类，编译器仍然要给它一个空间，所以类A即便什么都没有，它的空间大小也是1
    cout<<sizeof(A2)<<endl; //而类A2大小是类中的两个字符d、e之和，所以它的空间大小依然是2
    A *p1=new A();
    A p2;
    A *p3;
    //至于p1 p2 p3，p1和p3是指针，所以它们的大小是一定的，因此是4，p2是类A的对象，所以它的大小和类A相等，也是1
    cout<<sizeof(p1)<<endl;
    cout<<sizeof(p2)<<endl;
    cout<<sizeof(p3)<<endl;
    cout<<sizeof(B)<<endl;
    cout<<sizeof(C)<<endl;
    cout<<sizeof(D)<<endl;
}

#include<iostream>
using namespace std;

class A1
{
public:
    int a;
    static int b;  //static在全局变量区，不属于对象
    A1();
    ~A1();
};

class A2
{
public:
    int a;
    char c;
    A2();
    ~A2();
};

class A3
{
public:
    float a;
    char c;
    A3();
    ~A3();
};

class A4
{
public:
    float a;
    int b;
    char c;
    A4();
    ~A4();
};

class A5
{
public:
    double d;
    float a;
    int b;
    char c;
    A5();
    ~A5();
};

int main()
{
    cout<<sizeof(A1)<<endl;
    cout<<sizeof(A2)<<endl;
    cout<<sizeof(A3)<<endl;
    cout<<sizeof(A4)<<endl;
    cout<<sizeof(A5)<<endl;

}

#include<iostream>
#include<memory>
#include<assert.h>
using namespace std;

class A{ };

class A2{};

class B:public A{};

class C:public virtual B{};

class D:public A,public A2{};

int main()
{
    cout<<"sizeof(A): "<<sizeof(A)<<endl;
    cout<<"sizeof(B): "<<sizeof(B)<<endl;
    cout<<"sizeof(C): "<<sizeof(C)<<endl;
    cout<<"sizeof(D): "<<sizeof(D)<<endl;
}

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