C/C++基本类型占用内存总结

最新推荐文章于 2022-07-11 18:20:23 发布
最新推荐文章于 2022-07-11 18:20:23 发布
阅读量817 收藏 1
点赞数 1
分类专栏： C/C++学习 文章标签： C / C ++ 基本类型占用字节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010090635/article/details/82699188
版权

C/C++类型占用内存总结

C语言

C代码32位注释

/*************************************************************************
    > Description: ubuntu32位GCC4.8.4下面各变量类型大小
 ************************************************************************/

#include <stdio.h>
#include <string.h>

enum color {
    BLACK = 0,
    YELLOW = 1,
    WHITE,
    BLUE
};  //4 Byte

/*
 * 字节对齐原则：
 *   1.数据类型自身的对齐值:对于char型数据，为1；对于short型，为2，对于int,float型，为4；double类型，为8，单位字节
 *   2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值
 *   3.指定对齐值：#pragma pack (value)时的指定对齐值value。
 *   4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值
 * 注意:32位GCC默认指定对齐为4字节,64位GCC默认指定对齐为8字节
 *     VS2010不管是32位还是64位编译器,其默认指定对齐值为结构体或者类的自身对齐值(成员中自身对齐值最大的值)
 */
struct person8 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用4字节，自身1字节
    int height;     //占用4字节
    char name[5];   //占用8字节，自身5字节
    double weight;    //占用8字节
    char addr;      //占用4字节，自身1字节
};  //32 Byte   有效对齐值4

struct person4 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用4字节，自身1字节
    int height;     //占用4字节
};  //12 Byte   有效对齐值4

struct person2 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用2字节，自身1字节
};  //6 Byte   有效对齐值2

struct person1 {
    char gender;    //占用1字节，自身1字节
};  //1 Byte   有效对齐值1

/*
 * #pragma pack(1/2/4/8)修改指定对齐字节数
 * 注意：修改并不一定能奏效，因为还要看结构中成员最大那个对齐值
 *      成员最大对齐值超过指定对齐值，指定才能起作用
 */
#pragma pack(2)
struct Pragma_2
{
    int   a;    //4
    char  b;    //2
    double c;   //8
    char  d;    //2
};  //16 Byte   有效对齐值2

#pragma pack(1)
struct Pragma_1
{
    char  a;    //1
    double b;   //8
    char  c;    //1
};  //10 Byte   有效对齐值1
#pragma pack()

typedef struct IP {
    unsigned char szIP1;    //high
    unsigned char szIP2;
    unsigned char szIP3;
    unsigned char szIP4;
}IP_INT;

typedef union IP_addr {
    IP_INT ip_int;
    int ipv4;
    char type;
}IP_ADDR;   //4 Byte

static double function(int a, float b)
{
    return 0;
}

int main(void)
{
    char szchar = 65;   //1字节
    unsigned char uszchar = 95; //1字节

    short sishort = -100;   //2字节
    unsigned short usishort = 100;  //2字节

    int iint = -200;    //4字节
    unsigned int uiint= 200;    //4字节

    float ffloat = -0.8;    //4字节
    double ddouble = 99.99; //8字节

    long llong = 999;   //4字节
    unsigned long ullong = 999; //4字节
    long long lllong = 9999;    //8字节

    enum color color1;  //4字节
    union IP_addr pc_ip;    //4字节

    char* pchar;    //4字节
    int* pint;  //4字节
    long long* pllint;  //4字节
    double* pdouble;    //4字节

    double (*pffun)(int,float); //4字节

    /*
     * sizeof计算大小计算整个字符串长度
     * strlen计算截止到'\0'的字符长度
     */
    char str1[] = "12345\0678";     //str1字符串加上结束符'\0'一共占用8字节,'\067'表示一个字符
    char str2[] = "12345\\0678";    //str2字符串加上结束符'\0'一共占用11字节,'\\'表示一个'\'字符

    /* ArryNames是一个数组，故sizeof(ArryNames)大小为72字节 */
    char ArryNames[9][8] = {"Tom","Jerry","Ham","Jobs","","Benson","Nick","Evan","jiexue"};
    /* names是一个指针数组，故sizeof(names)大小为36字节 */
    const char* names[9] = {"Tom","Jerry","Ham","Jobs","","Benson","Nick","Evan","jiexue"};

    printf("    -----------------------------    \n");
    printf("****在%d位系统上,各类型占用字节数****\n", sizeof(void*) * 8);
    printf("****      GCC Version: %s     ****\n", __VERSION__);
    printf("    -----------------------------    \n");
    printf("-------------基本类型----------------\n");
    printf("char: %d\n", sizeof(szchar));
    printf("unsigned char: %d\n", sizeof(uszchar));
    printf("short: %d\n", sizeof(sishort));
    printf("unsigned short: %d\n", sizeof(usishort));
    printf("int: %d\n", sizeof(iint));
    printf("unsigned int: %d\n", sizeof(uiint));
    printf("float: %d\n", sizeof(ffloat));
    printf("double: %d\n", sizeof(ddouble));
    printf("long: %d\n", sizeof(llong));
    printf("unsigned long: %d\n", sizeof(ullong));
    printf("long long: %d\n", sizeof(lllong));

    printf("---------枚举、结构、联合------------\n");
    printf("enum: %d\n", sizeof(enum color));
    printf("struct person8: %d\n", sizeof(struct person8));
    printf("struct person4: %d\n", sizeof(struct person4));
    printf("struct person2: %d\n", sizeof(struct person2));
    printf("struct person1: %d\n", sizeof(struct person1));
    printf("union IPV4: %d\n", sizeof(pc_ip));

    printf("--------指针、函数、函数指针---------\n");
    printf("char*: %d\n", sizeof(char*));
    printf("int*: %d\n", sizeof(pint));
    printf("long long*: %d\n", sizeof(pllint));
    printf("double*: %d\n", sizeof(pdouble));
    printf("main: %d\n", sizeof(main)); //标准C禁止这么使用，GCC返回1，VS编译不通过
    printf("function: %d\n", sizeof(function)); //标准C禁止这么使用，GCC返回1，VS编译不通过
    printf("&main: %d\n", sizeof(&main)); //返回4
    printf("&function: %d\n", sizeof(&function));    //返回4
    printf("main(): %d\n", sizeof(main())); //返回4
    printf("function*: %d\n", sizeof(pffun));

    printf("---------------字符串----------------\n");
    printf("str1[] = \"12345\\0678\": %d\n",strlen(str1));
    printf("str1[] = \"12345\\0678\": %d\n", sizeof(str1));
    printf("str2[] = \"12345\\\\0678\": %d\n",strlen(str2));
    printf("str2[] = \"12345\\\\0678\": %d\n", sizeof(str2));
    printf("char ArryNames[9][8]: %d\n", sizeof(ArryNames));
    printf("char ArryNames[9][8]: %d\n", strlen(ArryNames[0])); //strlen(ArryNames)会给警告，得到的依然是3
    printf("char* names[9]: %d\n", sizeof(names));

    printf("------------修改对齐方式-------------\n");
    printf("struct Pragma_2: %d\n", sizeof(struct Pragma_2));
    printf("struct Pragma_1: %d\n", sizeof(struct Pragma_1));

    getchar();

    return 0;
}

输出

    -----------------------------    
****在32位系统上,各类型占用字节数****
****      GCC Version: 4.8.4     ****
    -----------------------------    
-------------基本类型----------------
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 4
unsigned long: 4
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 32
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 4
int*: 4
long long*: 4
double*: 4
main: 1
function: 1
&main: 4
&function: 4
main(): 4
function*: 4
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 36
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
    -----------------------------    
****在32位系统上,各类型占用字节数****
****  Visual Studio 2010 win32   ****
    -----------------------------    
-------------基本类型----------------
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 4
unsigned long: 4
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 40
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 4
int*: 4
long long*: 4
double*: 4
&main: 4
&function: 4
main(): 4
function*: 4
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 36
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
请按任意键继续. . .

C代码64位注释

/*************************************************************************
    > Description: GCC4.2.1下面各变量类型大小
 ************************************************************************/

#include <stdio.h>
#include <string.h>

enum color {
    BLACK = 0,
    YELLOW = 1,
    WHITE,
    BLUE
};  //4 Byte

/*
 * 字节对齐原则：
 *   1.数据类型自身的对齐值:对于char型数据，为1；对于short型，为2，对于int,float型，为4；double类型，为8，单位字节
 *   2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值
 *   3.指定对齐值：#pragma pack (value)时的指定对齐值value。
 *   4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值
 * 注意:32位GCC默认指定对齐为4字节,64位GCC默认指定对齐为8字节
 *     VS2010不管是32位还是64位编译器,其默认指定对齐值为结构体或者类的自身对齐值(成员中自身对齐值最大的值)
 */
struct person8 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用4字节，自身1字节
    int height;     //占用4字节
    char name[5];   //占用12字节，自身5字节
    double weight;    //占用8字节
    char addr;      //占用8字节，自身1字节
};  //40 Byte   有效对齐值8

struct person4 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用4字节，自身1字节
    int height;     //占用4字节
};  //12 Byte   有效对齐值4

struct person2 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用2字节，自身1字节
};  //6 Byte   有效对齐值2

struct person1 {
    char gender;    //占用1字节，自身1字节
};  //1 Byte   有效对齐值1

/*
 * #pragma pack(1/2/4/8)修改指定对齐字节数
 * 注意：修改并不一定能奏效，因为还要看结构中成员最大那个对齐值
 *      成员最大对齐值超过指定对齐值，指定才能起作用
 */
#pragma pack(2)
struct Pragma_2
{
    int   a;    //4
    char  b;    //2
    double c;   //8
    char  d;    //2
};  //16 Byte   有效对齐值2

#pragma pack(1)
struct Pragma_1
{
    char  a;    //1
    double b;   //8
    char  c;    //1
};  //10 Byte   有效对齐值1
#pragma pack()

typedef struct IP {
    unsigned char szIP1;    //high
    unsigned char szIP2;
    unsigned char szIP3;
    unsigned char szIP4;
}IP_INT;

typedef union IP_addr {
    IP_INT ip_int;
    int ipv4;
    char type;
}IP_ADDR;   //4 Byte

static double function(int a, float b)
{
    return 0;
}

int main(void)
{
    char szchar = 65;   //1字节
    unsigned char uszchar = 95; //1字节

    short sishort = -100;   //2字节
    unsigned short usishort = 100;  //2字节

    int iint = -200;    //4字节
    unsigned int uiint= 200;    //4字节

    float ffloat = -0.8;    //4字节
    double ddouble = 99.99; //8字节

    long llong = 999;   //8字节
    unsigned long ullong = 999; //8字节
    long long lllong = 9999;    //8字节

    enum color color1;  //4字节
    union IP_addr pc_ip;    //4字节

    char* pchar;    //8字节
    int* pint;  //8字节
    long long* pllint;  //8字节
    double* pdouble;    //8字节

    double (*pffun)(int,float); //8字节

    /*
     * sizeof计算大小计算整个字符串长度
     * strlen计算截止到'\0'的字符长度
     */
    char str1[] = "12345\0678";     //str1字符串加上结束符'\0'一共占用8字节,'\067'表示一个字符
    char str2[] = "12345\\0678";    //str2字符串加上结束符'\0'一共占用11字节,'\\'表示一个'\'字符

    /* ArryNames是一个数组，故sizeof(ArryNames)大小为72字节 */
    char ArryNames[9][8] = {"Tom","Jerry","Ham","Jobs","","Benson","Nick","Evan","jiexue"};
    /* names是一个指针数组，故sizeof(names)大小为72字节 */
    const char* names[9] = {"Tom","Jerry","Ham","Jobs","","Benson","Nick","Evan","jiexue"};

    printf("    -----------------------------    \n");
    printf("****在%d位系统上,各类型占用字节数****\n", sizeof(void*) * 8);
    printf("****      GCC Version: %s     ****\n", __VERSION__);
    printf("    -----------------------------    \n");
    printf("-------------基本类型----------------\n");
    printf("char: %d\n", sizeof(szchar));
    printf("unsigned char: %d\n", sizeof(uszchar));
    printf("short: %d\n", sizeof(sishort));
    printf("unsigned short: %d\n", sizeof(usishort));
    printf("int: %d\n", sizeof(iint));
    printf("unsigned int: %d\n", sizeof(uiint));
    printf("float: %d\n", sizeof(ffloat));
    printf("double: %d\n", sizeof(ddouble));
    printf("long: %d\n", sizeof(llong));
    printf("unsigned long: %d\n", sizeof(ullong));
    printf("long long: %d\n", sizeof(lllong));

    printf("---------枚举、结构、联合------------\n");
    printf("enum: %d\n", sizeof(enum color));
    printf("struct person8: %d\n", sizeof(struct person8));
    printf("struct person4: %d\n", sizeof(struct person4));
    printf("struct person2: %d\n", sizeof(struct person2));
    printf("struct person1: %d\n", sizeof(struct person1));
    printf("union IPV4: %d\n", sizeof(pc_ip));

    printf("--------指针、函数、函数指针---------\n");
    printf("char*: %d\n", sizeof(char*));
    printf("int*: %d\n", sizeof(pint));
    printf("long long*: %d\n", sizeof(pllint));
    printf("double*: %d\n", sizeof(pdouble));
    printf("main: %d\n", sizeof(main)); //标准C禁止这么使用，GCC返回1，VS编译不通过
    printf("function: %d\n", sizeof(function)); //标准C禁止这么使用，GCC返回1，VS编译不通过
    printf("&main: %d\n", sizeof(&main)); //返回8
    printf("&function: %d\n", sizeof(&function));    //返回8
    printf("main(): %d\n", sizeof(main())); //返回4
    printf("function*: %d\n", sizeof(pffun));

    printf("---------------字符串----------------\n");
    printf("str1[] = \"12345\\0678\": %d\n",strlen(str1));
    printf("str1[] = \"12345\\0678\": %d\n", sizeof(str1));
    printf("str2[] = \"12345\\\\0678\": %d\n",strlen(str2));
    printf("str2[] = \"12345\\\\0678\": %d\n", sizeof(str2));
    printf("char ArryNames[9][8]: %d\n", sizeof(ArryNames));
    printf("char ArryNames[9][8]: %d\n", strlen(ArryNames[0])); //strlen(ArryNames)会给警告，得到的依然是3
    printf("char* names[9]: %d\n", sizeof(names));

    printf("------------修改对齐方式-------------\n");
    printf("struct Pragma_2: %d\n", sizeof(struct Pragma_2));
    printf("struct Pragma_1: %d\n", sizeof(struct Pragma_1));

    getchar();

    return 0;
}

输出

    -----------------------------    
****在64位系统上,各类型占用字节数****
****      GCC Version: 4.2.1     ****
    -----------------------------    
-------------基本类型----------------
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 8
unsigned long: 8
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 40
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 8
int*: 8
long long*: 8
double*: 8
main: 1
function: 1
&main: 8
&function: 8
main(): 4
function*: 8
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 72
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
    -----------------------------    
****在64位系统上,各类型占用字节数****
****      GCC Version: 6.3.0     ****
    -----------------------------    
-------------基本类型----------------
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 8
unsigned long: 8
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 40
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 8
int*: 8
long long*: 8
double*: 8
main: 1
function: 1
&main: 8
&function: 8
main(): 4
function*: 8
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 72
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
    -----------------------------    
****在64位系统上,各类型占用字节数****
****   Visual Studio 2010 X64    ****
    -----------------------------   
-------------基本类型----------------
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 4
unsigned long: 4
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 40
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 8
int*: 8
long long*: 8
double*: 8
&main: 8
&function: 8
main(): 4
function*: 8
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 72
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
请按任意键继续. . .

总结

  • 对于GCC编译器而言，32位与64位的差别主要体现在三个方面
    • 字节32位默认以4字节对齐，64位以8字节对齐
    • 对于指针32位占用4字节，64位占用8字节
    • long型在32位上占用4字节，64位占用8字节
  • 对于VS2010编译器而言，32位与64位的区别
    • 32位和64位默认都以结构体的自身对齐值对齐，除非指定比自身对齐值小的对齐值
    • 对于指针32位占用4字节，64位占用8字节
    • long型在32位和64位都占用4字节

C++语言

C++代码32位注释

/*************************************************************************
    > Description: C++基本类型、类在32位GCC4.8.4 编译器下占用的内存大小
 ************************************************************************/

#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>

using namespace std;

enum color {
    BLACK = 0,
    YELLOW = 1,
    WHITE,
    BLUE
};  //4 Byte

/*
 * 字节对齐原则：
 *   1.数据类型自身的对齐值:对于char型数据，为1；对于short型，为2，对于int,float型，为4；double类型，为8，单位字节
 *   2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值
 *   3.指定对齐值：#pragma pack (value)时的指定对齐值value。
 *   4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值
 * 注意:32位GCC默认指定对齐为4字节,64位GCC默认指定对齐为8字节
 *     VS2010不管是32位还是64位编译器,其默认指定对齐值为结构体或者类的自身对齐值(成员中自身对齐值最大的值)
 */
struct person8 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用4字节，自身1字节
    int height;     //占用4字节
    char name[5];   //占用8字节，自身5字节
    double weight;    //占用8字节
    char addr;      //占用4字节，自身1字节
};  //32 Byte   有效对齐值4

struct person4 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用4字节，自身1字节
    int height;     //占用4字节
};  //12 Byte   有效对齐值4

struct person2 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用2字节，自身1字节
};  //6 Byte   有效对齐值2

struct person1 {
    char gender;    //占用1字节，自身1字节
};  //1 Byte   有效对齐值1

/*
 * #pragma pack(1/2/4/8)修改指定对齐字节数
 * 注意：修改并不一定能奏效，因为还要看结构中成员最大那个对齐值
 *      成员最大对齐值超过指定对齐值，指定才能起作用
 */
#pragma pack(2)
struct Pragma_2
{
    int   a;    //4
    char  b;    //2
    double c;   //8
    char  d;    //2
};  //16 Byte   有效对齐值2

#pragma pack(1)
struct Pragma_1
{
    char  a;    //1
    double b;   //8
    char  c;    //1
};  //10 Byte   有效对齐值1
#pragma pack()

typedef struct IP {
    unsigned char szIP1;    //high
    unsigned char szIP2;
    unsigned char szIP3;
    unsigned char szIP4;
}IP_INT;

typedef union IP_addr {
    IP_INT ip_int;
    int ipv4;
    char type;
}IP_ADDR;   //4 Byte

static double function(int a, float b)
{
    return 0;
}

/*
 * 1.类的大小为类的非静态成员数据的类型大小之和，也就是说静态成员数据不作考虑;
 * 2.类的总大小也遵守类似class字节对齐的;
 * 3.成员函数都是不会被计算的; 
 * 4.如果是子类，那么父类中的成员也会被计算;
 * 5.虚函数由于要维护虚函数表，所以要占据一个指针大小，也就是4字节.
 * 总结：一个类中，虚函数、成员函数（包括静态与非静态）和静态数据成员都不占用类对象的存储空间
 */
class Person {
private:
    unsigned short age; //占用2字节
    bool gender;        //占用1字节
    char name[16];      //占用17字节
public:
    /* 联合，占用16字节 */
    union UBffer
    {
        char buffer[13];
        int number;
    }ubuf;

    typedef char*(*f)(void*);   //不占用类对象内存
    enum{hdd,ssd,blueray}disk;  //占用4字节,按int存储

    /* 成员函数，不占用类对象的内存 */
    Person(const char* name, bool gender, unsigned short age) {
        strcpy(Person::name, name);
        Person::gender = gender;
        Person::age = age;
    }

    ~Person() {cout << "~Person\n";}

    friend ostream& operator<<(ostream& out, Person& p) {
        return out << "name:" << p.name << " gender:" << p.gender << " age:" << p.age; 
    } 
};  //40 Byte 有效对齐值4

/*
 * 空类型的实例中不包含任何信息，本来求sizeof的结果应该是0，但是当我们声明该类型的实例时，必须在内存中占有一定得空间，否则无法使用这些实例。
 * 至于占多少内存，由编译器决定。在GCC和Visual Studio中，每个空类型的实例占用1字节的空间。
 */
class None {

};  //1 Byte

class Parent {
private:
    static char sch;    //非实例独占,不占用实例内存
    char ch;    //占用4字节
    int* pi;    //占用4字节
public:
    Parent() {} //相当于普通函数，不占用实例内存

    /* 几个虚函数只占用一个虚函数表,只占用一个指针的大小4字节 */
    virtual void fun1() {}
    virtual void fun2() {}
    virtual ~Parent();
};  //12 Byte 有效对齐值4

class Child : public Parent{
private:
    double d;   //占用8字节
    string str; //占用4字节
public:
    Child() {}

    /* 
     * 子类将父类虚函数表继承下来,只占用一个指针的大小4字节
     * 也就是说父类有虚函数的情况下子类的虚函数不占用内存
     */
    virtual void fun1() {}
    virtual void fun3() {}
    virtual ~Child() {} 
};  //24 Byte 有效对齐值4

int main(void)
{
    /* string的实现在各库中可能有所不同，但在同一个库中相同的一点是，无论string里存放了多长的字符串，它们的sizeof()都是固定的
     *（举个不太恰当的例子，就好比int a; 无论int变量a取多大的值，sizeof(a)总为4），字符串所占的空间是从堆中动态分配的，与sizeof()无关；
     * sizeof(string) == 4可能是最为典型的实现之一，不过也有sizeof()为 12，32 字节的库，同时也与编译器有关
     * 在windows 64位操作系统下， 使用vs2010 32位编译器测试，sizeof(string) == 32。
     * 在windows 64位操作系统下， 使用vs2010 64位编译器测试，sizeof(string) == 48。
     */
    bool bl;    //1字节
    string Str = "Hello! How do you do!";   //4字节

    char szchar = 65;   //1字节
    unsigned char uszchar = 95; //1字节

    short sishort = -100;   //2字节
    unsigned short usishort = 100;  //2字节

    int iint = -200;    //4字节
    unsigned int uiint= 200;    //4字节

    float ffloat = -0.8;    //4字节
    double ddouble = 99.99; //8字节

    long llong = 999;   //4字节
    unsigned long ullong = 999; //4字节
    long long lllong = 9999;    //8字节

    enum color color1;  //4字节
    union IP_addr pc_ip;    //4字节

    char* pchar;    //4字节
    int* pint;  //4字节
    long long* pllint;  //4字节
    double* pdouble;    //4字节

    double (*pffun)(int,float); //4字节

    /*
     * sizeof计算大小计算整个字符串长度
     * strlen计算截止到'\0'的字符长度
     */
    char str1[] = "12345\0678";     //str1字符串加上结束符'\0'一共占用8字节,'\067'表示一个字符
    char str2[] = "12345\\0678";    //str2字符串加上结束符'\0'一共占用11字节,'\\'表示一个'\'字符

    /* ArryNames是一个数组，故sizeof(ArryNames)大小为72字节 */
    char ArryNames[9][8] = {"Tom","Jerry","Ham","Jobs","","Benson","Nick","Evan","jiexue"};
    /* names是一个指针数组，故sizeof(names)大小为36字节 */
    const char* names[9] = {"Tom","Jerry","Ham","Jobs","","Benson","Nick","Evan","jiexue"};

    Person p("jiexue", true, 18);

    cout << "    -----------------------------    \n";
    cout << "****在" << sizeof(void*) * 8 << "位系统上,各类型占用字节数****\n";
    cout << "****      GCC Version: " << __VERSION__ << "     ****\n";
    cout << "    -----------------------------    \n";
    cout << "-------------基本类型----------------\n";
    cout << "bool: " << sizeof(bl) << endl;
    cout << "string: " << sizeof(Str) << endl;
    cout << "char: " << sizeof(szchar) << endl;
    cout << "unsigned char: " << sizeof(uszchar) << endl;
    cout << "short: " << sizeof(sishort) << endl;
    cout << "unsigned short: " << sizeof(usishort) << endl;
    cout << "int: " <<  sizeof(iint) << endl;
    cout << "unsigned int: " << sizeof(uiint) << endl;
    cout << "float: " << sizeof(ffloat) << endl;
    cout << "double: " << sizeof(ddouble) << endl;
    cout << "long: " << sizeof(llong) << endl;
    cout << "unsigned long: " << sizeof(ullong) << endl;
    cout << "long long: " << sizeof(lllong) << endl;

    cout << "---------枚举、结构、联合------------\n";
    cout << "enum: " << sizeof(enum color) << endl;
    cout << "struct person8: " << sizeof(person8) << endl;
    cout << "struct person4: " << sizeof(person4) << endl;
    cout << "struct person2: " << sizeof(person2) << endl;
    cout << "struct person1: " << sizeof(person1) << endl;
    cout << "union IPV4: " << sizeof(pc_ip) << endl;

    cout << "--------指针、函数、函数指针---------\n";
    cout << "char*: " << sizeof(char*) << endl;
    cout << "int*: " << sizeof(pint) << endl;
    cout << "long long*: " << sizeof(pllint) << endl;
    cout << "double*: " << sizeof(pdouble) << endl;
    cout << "&main: " << sizeof(&main) << endl; //返回4
    cout << "&function: " << sizeof(&function) << endl;    //返回4
    cout << "main(): " << sizeof(main()) << endl; //返回4
    cout << "function*: " << sizeof(pffun) << endl;

    cout << "---------------字符串----------------\n";
    cout << "str1[] = \"12345\\0678\": " << strlen(str1) << endl;
    cout << "str1[] = \"12345\\0678\": " << sizeof(str1) << endl;
    cout << "str2[] = \"12345\\\\0678\": " << strlen(str2) << endl;
    cout << "str2[] = \"12345\\\\0678\": " << sizeof(str2) << endl;
    cout << "char ArryNames[9][8]: " << sizeof(ArryNames) << endl;
    cout << "char ArryNames[9][8]: " << strlen(ArryNames[0]) << endl; //strlen(ArryNames)会给警告，得到的依然是3
    cout << "char* names[9]: " << sizeof(names) << endl;

    cout << "------------修改对齐方式-------------\n";
    cout << "struct Pragma_2: " << sizeof(struct Pragma_2) << endl;
    cout << "struct Pragma_1: " << sizeof(struct Pragma_1) << endl;

    cout << "---------------C++类----------------\n";
    cout << "class Person: " << sizeof(Person ("jiexue", true, 18)) << endl;
    cout << p << endl;
    cout << "class None: " << sizeof(None) << endl;
    cout << "class Parent: " << sizeof(Parent) << endl;
    cout << "class Child: " << sizeof(Child) << endl;

    //getchar();
    //system("PAUSE");

    return 0;
}

输出

    -----------------------------    
****在32位系统上,各类型占用字节数****
****      GCC Version: 4.8.4     ****
    -----------------------------    
-------------基本类型----------------
bool: 1
string: 4
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 4
unsigned long: 4
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 32
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 4
int*: 4
long long*: 4
double*: 4
&main: 4
&function: 4
main(): 4
function*: 4
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 36
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
---------------C++类----------------
class Person: 40
name:jiexue gender:1 age:18
class None: 1
class Parent: 12
class Child: 24
~Person
    -----------------------------    
****在32位系统上,各类型占用字节数****
****  Visual Studio 2010 win32   ****
    -----------------------------    
-------------基本类型----------------
bool: 1
string: 32
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 4
unsigned long: 4
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 40
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 4
int*: 4
long long*: 4
double*: 4
&main: 4
&function: 4
main(): 4
function*: 4
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 36
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
---------------C++类----------------
class Person: 40
name:jiexue gender:1 age:18
class None: 1
class Parent: 12
class Child: 56
请按任意键继续. . .

C++代码64位注释

/*************************************************************************
    > Description: C++基本类型、类在GCC 64位编译器下占用的内存大小
 ************************************************************************/

#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>

using namespace std;

enum color {
    BLACK = 0,
    YELLOW = 1,
    WHITE,
    BLUE
};  //4 Byte

/*
 * 字节对齐原则：
 *   1.数据类型自身的对齐值:对于char型数据，为1；对于short型，为2，对于int,float型，为4；double类型，为8，单位字节
 *   2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值
 *   3.指定对齐值：#pragma pack (value)时的指定对齐值value。
 *   4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值
 * 注意:32位GCC默认指定对齐为4字节,64位GCC默认指定对齐为8字节
 *     VS2010不管是32位还是64位编译器,其默认指定对齐值为结构体或者类的自身对齐值(成员中自身对齐值最大的值)
 */
struct person8 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用4字节，自身1字节
    int height;     //占用4字节
    char name[5];   //占用12字节，自身5字节
    double weight;    //占用8字节
    char addr;      //占用8字节，自身1字节
};  //40 Byte   有效对齐值8

struct person4 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用4字节，自身1字节
    int height;     //占用4字节
};  //12 Byte   有效对齐值4

struct person2 {
    char gender;    //占用2字节，自身1字节
    short age;      //占用2字节
    char party;     //占用2字节，自身1字节
};  //6 Byte   有效对齐值2

struct person1 {
    char gender;    //占用1字节，自身1字节
};  //1 Byte   有效对齐值1

/*
 * #pragma pack(1/2/4/8)修改指定对齐字节数
 * 注意：修改并不一定能奏效，因为还要看结构中成员最大那个对齐值
 *      成员最大对齐值超过指定对齐值，指定才能起作用
 */
#pragma pack(2)
struct Pragma_2
{
    int   a;    //4
    char  b;    //2
    double c;   //8
    char  d;    //2
};  //16 Byte   有效对齐值2

#pragma pack(1)
struct Pragma_1
{
    char  a;    //1
    double b;   //8
    char  c;    //1
};  //10 Byte   有效对齐值1
#pragma pack()

typedef struct IP {
    unsigned char szIP1;    //high
    unsigned char szIP2;
    unsigned char szIP3;
    unsigned char szIP4;
}IP_INT;

typedef union IP_addr {
    IP_INT ip_int;
    int ipv4;
    char type;
}IP_ADDR;   //4 Byte

static double function(int a, float b)
{
    return 0;
}

/*
 * 1.类的大小为类的非静态成员数据的类型大小之和，也就是说静态成员数据不作考虑;
 * 2.类的总大小也遵守类似class字节对齐的;
 * 3.成员函数都是不会被计算的; 
 * 4.如果是子类，那么父类中的成员也会被计算;
 * 5.虚函数由于要维护虚函数表，所以要占据一个指针大小，也就是4字节.
 * 总结：一个类中，虚函数、成员函数（包括静态与非静态）和静态数据成员都不占用类对象的存储空间
 */
class Person {
private:
    unsigned short age; //占用2字节
    bool gender;        //占用1字节
    char name[16];      //占用17字节
public:
    /* 联合，占用16字节 */
    union UBffer
    {
        char buffer[13];
        int number;
    }ubuf;

    typedef char*(*f)(void*);   //不占用类对象内存
    enum{hdd,ssd,blueray}disk;  //占用4字节,按int存储

    /* 成员函数，不占用类对象的内存 */
    Person(const char* name, bool gender, unsigned short age) {
        strcpy(Person::name, name);
        Person::gender = gender;
        Person::age = age;
    }

    ~Person() {cout << "~Person\n";}

    friend ostream& operator<<(ostream& out, Person& p) {
        return out << "name:" << p.name << " gender:" << p.gender << " age:" << p.age; 
    } 
};  //40 Byte 有效对齐值４

/*
 * 空类型的实例中不包含任何信息，本来求sizeof的结果应该是0，但是当我们声明该类型的实例时，必须在内存中占有一定得空间，否则无法使用这些实例。
 * 至于占多少内存，由编译器决定。在GCC和Visual Studio中，每个空类型的实例占用1字节的空间。
 */
class None {

};  //1 Byte

class Parent {
private:
    static char sch;    //非实例独占,不占用实例内存
    char ch;    //占用8字节,自身1字节
    int* pi;    //占用8字节
public:
    Parent() {} //相当于普通函数，不占用实例内存

    /* 几个虚函数只占用一个虚函数表,只占用一个指针的大小8字节 */
    virtual void fun1() {}
    virtual void fun2() {}
    virtual ~Parent();
};  //24 Byte 有效对齐值8

class Child : public Parent{
private:
    double d;   //占用8字节
    string str; //占用32字节
public:
    Child() {}

    /* 
     * 子类将父类虚函数表继承下来,只占用一个指针的大小8字节
     * 也就是说父类有虚函数的情况下子类的虚函数不占用内存
     */
    virtual void fun1() {}
    virtual void fun3() {}
    virtual ~Child() {} 
};  //64 Byte 有效对齐值8

int main(void)
{
    /* string的实现在各库中可能有所不同，但在同一个库中相同的一点是，无论string里存放了多长的字符串，它们的sizeof()都是固定的
     * （举个不太恰当的例子，就好比int a; 无论int变量a取多大的值，sizeof(a)总为4），字符串所占的空间是从堆中动态分配的，与sizeof()无关；
     * sizeof(string) == 4可能是最为典型的实现之一，不过也有sizeof()为 12，32 字节的库，同时也与编译器有关
     * 在windows 64位操作系统下， 使用vs2010 32位编译器测试，sizeof(string) == 32。
     * 在windows 64位操作系统下， 使用vs2010 64位编译器测试，sizeof(string) == 48。
     */
    bool bl;    //1字节
    string Str = "Hello! How do you do!";   //32字节

    char szchar = 65;   //1字节
    unsigned char uszchar = 95; //1字节

    short sishort = -100;   //2字节
    unsigned short usishort = 100;  //2字节

    int iint = -200;    //4字节
    unsigned int uiint= 200;    //4字节

    float ffloat = -0.8;    //4字节
    double ddouble = 99.99; //8字节

    long llong = 999;   //8字节
    unsigned long ullong = 999; //8字节
    long long lllong = 9999;    //8字节

    enum color color1;  //4字节
    union IP_addr pc_ip;    //4字节

    char* pchar;    //8字节
    int* pint;  //8字节
    long long* pllint;  //8字节
    double* pdouble;    //8字节

    double (*pffun)(int,float); //8字节

    /*
     * sizeof计算大小计算整个字符串长度
     * strlen计算截止到'\0'的字符长度
     */
    char str1[] = "12345\0678";     //str1字符串加上结束符'\0'一共占用8字节,'\067'表示一个字符
    char str2[] = "12345\\0678";    //str2字符串加上结束符'\0'一共占用11字节,'\\'表示一个'\'字符

    /* ArryNames是一个数组，故sizeof(ArryNames)大小为72字节 */
    char ArryNames[9][8] = {"Tom","Jerry","Ham","Jobs","","Benson","Nick","Evan","jiexue"};
    /* names是一个指针数组，故sizeof(names)大小为72字节 */
    const char* names[9] = {"Tom","Jerry","Ham","Jobs","","Benson","Nick","Evan","jiexue"};

    Person p("jiexue", true, 18);

    cout << "    -----------------------------    \n";
    cout << "****在" << sizeof(void*) * 8 << "位系统上,各类型占用字节数****\n";
    cout << "****      GCC Version: " << __VERSION__ << "     ****\n";
    cout << "    -----------------------------    \n";
    cout << "-------------基本类型----------------\n";
    cout << "bool: " << sizeof(bl) << endl;
    cout << "string: " << sizeof(Str) << endl;
    cout << "char: " << sizeof(szchar) << endl;
    cout << "unsigned char: " << sizeof(uszchar) << endl;
    cout << "short: " << sizeof(sishort) << endl;
    cout << "unsigned short: " << sizeof(usishort) << endl;
    cout << "int: " <<  sizeof(iint) << endl;
    cout << "unsigned int: " << sizeof(uiint) << endl;
    cout << "float: " << sizeof(ffloat) << endl;
    cout << "double: " << sizeof(ddouble) << endl;
    cout << "long: " << sizeof(llong) << endl;
    cout << "unsigned long: " << sizeof(ullong) << endl;
    cout << "long long: " << sizeof(lllong) << endl;

    cout << "---------枚举、结构、联合------------\n";
    cout << "enum: " << sizeof(enum color) << endl;
    cout << "struct person8: " << sizeof(person8) << endl;
    cout << "struct person4: " << sizeof(person4) << endl;
    cout << "struct person2: " << sizeof(person2) << endl;
    cout << "struct person1: " << sizeof(person1) << endl;
    cout << "union IPV4: " << sizeof(pc_ip) << endl;

    cout << "--------指针、函数、函数指针---------\n";
    cout << "char*: " << sizeof(char*) << endl;
    cout << "int*: " << sizeof(pint) << endl;
    cout << "long long*: " << sizeof(pllint) << endl;
    cout << "double*: " << sizeof(pdouble) << endl;
    cout << "&main: " << sizeof(&main) << endl; //返回8
    cout << "&function: " << sizeof(&function) << endl;    //返回8
    cout << "main(): " << sizeof(main()) << endl; //返回4
    cout << "function*: " << sizeof(pffun) << endl;

    cout << "---------------字符串----------------\n";
    cout << "str1[] = \"12345\\0678\": " << strlen(str1) << endl;
    cout << "str1[] = \"12345\\0678\": " << sizeof(str1) << endl;
    cout << "str2[] = \"12345\\\\0678\": " << strlen(str2) << endl;
    cout << "str2[] = \"12345\\\\0678\": " << sizeof(str2) << endl;
    cout << "char ArryNames[9][8]: " << sizeof(ArryNames) << endl;
    cout << "char ArryNames[9][8]: " << strlen(ArryNames[0]) << endl; //strlen(ArryNames)会给警告，得到的依然是3
    cout << "char* names[9]: " << sizeof(names) << endl;

    cout << "------------修改对齐方式-------------\n";
    cout << "struct Pragma_2: " << sizeof(struct Pragma_2) << endl;
    cout << "struct Pragma_1: " << sizeof(struct Pragma_1) << endl;

    cout << "---------------C++类----------------\n";
    cout << "class Person: " << sizeof(Person ("jiexue", true, 18)) << endl;
    cout << p << endl;
    cout << "class None: " << sizeof(None) << endl;
    cout << "class Parent: " << sizeof(Parent) << endl;
    cout << "class Child: " << sizeof(Child) << endl;

    //getchar();
    //system("PAUSE");

    return 0;
}

输出

    -----------------------------    
****在64位系统上,各类型占用字节数****
****      GCC Version: 4.2.1     ****
    -----------------------------    
-------------基本类型----------------
bool: 1
string: 32
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 8
unsigned long: 8
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 40
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 8
int*: 8
long long*: 8
double*: 8
&main: 8
&function: 8
main(): 4
function*: 8
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 72
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
---------------C++类----------------
class Person: 40
name:jiexue gender:1 age:18
class None: 1
class Parent: 24
class Child: 64
~Person
    -----------------------------    
****在64位系统上,各类型占用字节数****
****      GCC Version: 6.3.0     ****
    -----------------------------    
-------------基本类型----------------
bool: 1
string: 32
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 8
unsigned long: 8
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 40
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 8
int*: 8
long long*: 8
double*: 8
&main: 8
&function: 8
main(): 4
function*: 8
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 72
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
---------------C++类----------------
class Person: 40
name:jiexue gender:1 age:18
class None: 1
class Parent: 24
class Child: 64
~Person
    -----------------------------    
****在64位系统上,各类型占用字节数****
****      GCC Version: 8.1.0     ****
    -----------------------------    
-------------基本类型----------------
bool: 1
string: 32
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 8
unsigned long: 8
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 40
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 8
int*: 8
long long*: 8
double*: 8
&main: 8
&function: 8
main(): 4
function*: 8
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 72
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
---------------C++类----------------
class Person: 40
name:jiexue gender:1 age:18
class None: 1
class Parent: 24
class Child: 64
~Person
    -----------------------------    
****在64位系统上,各类型占用字节数****
****   Visual Studio 2010 X64    ****
    -----------------------------    
-------------基本类型----------------
bool: 1
string: 48
char: 1
unsigned char: 1
short: 2
unsigned short: 2
int: 4
unsigned int: 4
float: 4
double: 8
long: 4
unsigned long: 4
long long: 8
---------枚举、结构、联合------------
enum: 4
struct person8: 40
struct person4: 12
struct person2: 6
struct person1: 1
union IPV4: 4
--------指针、函数、函数指针---------
char*: 8
int*: 8
long long*: 8
double*: 8
&main: 8
&function: 8
main(): 4
function*: 8
---------------字符串----------------
str1[] = "12345\0678": 7
str1[] = "12345\0678": 8
str2[] = "12345\\0678": 10
str2[] = "12345\\0678": 11
char ArryNames[9][8]: 72
char ArryNames[9][8]: 3
char* names[9]: 72
------------修改对齐方式-------------
struct Pragma_2: 16
struct Pragma_1: 10
---------------C++类----------------
class Person: 40
name:jiexue gender:1 age:18
class None: 1
class Parent: 24
class Child: 80
请按任意键继续. . .

总结

  • 对于GCC编译器而言，32位与64位的差别主要体现在三个方面
    • 字节32位默认以4字节对齐，64位以8字节对齐
    • 对于指针32位占用4字节，64位占用8字节
    • long型在32位上占用4字节，64位占用8字节
    • string实现在32位上占用4字节,在64位上占用32字节
  • 对于VS2010编译器而言，32位与64位的区别
    • 32位和64位默认都以结构体的自身对齐值对齐，除非指定比自身对齐值小的对齐值
    • 对于指针32位占用4字节，64位占用8字节
    • long型在32位和64位都占用4字节
    • string在32位下为32字节，在64位占用48字节

tips

  • 配置VS2010编译器为64位
    • 点击“Win32”下拉框，打开“配置管理器”
    • 点击工程名下的平台
    • 点击”新建”，新平台选择”X64”
    • 确定之后可以看到活动解决平台变成了”X64”
    • 新建好了后，可以在win32和X64之间自由切换
  • 配置VS2010默认指定对齐值
    • 选中工程名，右击选中”属性”
    • 选中”配置属性”，选中”C/C++”
    • 选中”Code Generation”，在”Struct Member Alignment”选项后面设置相应对齐值
不做老实人
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++实现linux和Windows查看系统、进程、服务的内存和CPU使用
11-30
C/C++实现linux和Windows查看系统、进程、服务的内存和CPU使用情况的源代码，生成的是静态链接库，Windows和Linux下经测试都可用，查看系统、指定名称的服务、指定名称的进程占用CPU和内存，查看方式不是通过程序中...
基于Ubuntu、树莓派、STM32分析C语言分区
weixin_44439920的博客
12-05 173
…
C/C++ 程序占用内存的分配机制-释放和回收理解
PHP代码的博客
07-11 3872
C/C++ 程序占用内存的分配机制-释放和回收理解
C++类所占内存大小计算
陈冲的博客
05-31 1万+
C++类所占内存大小计算 转载时请注明出处和作者联系方式 文章出处：http://blog.csdn.net/chenchong08 作者联系方式：vision_chen@yeah.net 说明：笔者的操作系统是32位的。 class A {}; sizeof( A ) = ? sizeof( A ) = 1 明明是空类，为什么编译器说它是1呢？ 空类同样可以实例化，每个实例在
C/C++程序占用内存说明
Yummy
04-15 3936
一、组成部分 1. 栈区(stack)：由编译器自动分配释放，存放函数参数值，局部变量的值等，操作类似于数据结构中的栈。栈内存分配内置于处理器的指令集，分配效率高但是内存容量有限，不会产生内存碎片，向着内存地址减小的方向生长； 2. 堆区(heap)：由程序员自动分配释放 ，若程序员不释放，容易导致内存泄漏，程序结束时可能由OS回收。堆内存分配类似于链表，分配效率低但是内存容量大，频繁的分...
C/C++中基本数据类型所占内存大小
热门推荐
ZMyths的博客
09-11 2万+
C中不同数据类型所占的字节大小，在不同的操作系统和编译器下，是不同的，一般主要说gcc下，32位或64位系统的，红色部分是32 和64位系统不同的，做了个表如下： char 1 1 -128~127 unsigned char(当byte使用) 1 1 0~255 short int /short　 2 2 –32,768~32,767 unsigned short 　 2 2 0~65,535 int 4 4 -2,147,483,648~2,147,483,647 unsigned int 4
QT/C++实时获取CPU和内存的使用率
12-17
总结来说，QT/C++获取CPU和内存使用率涉及的主要知识点包括：QT的跨平台特性，C++编程，操作系统的API调用，文件I/O，以及QT的事件驱动模型和用户界面设计。通过理解这些概念，开发者可以构建出一个高效、准确的系统...
java和c/c++ 数据类型长度的比较
09-04
总结来说，C/C++的数据类型长度更加灵活，但可能带来移植性问题，而Java的数据类型长度固定，有利于跨平台兼容性。程序员需要根据实际需求和目标平台选择合适的数据类型，以达到最佳的存储和计算效率。在编写代码时...
老生常谈C/C++内存管理
08-30
4. 全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。 5. 常量存储区：这是一块比较特殊的...
C/C++中的内存管理小结
12-17
在C/C++编程中，内存管理是至关重要的概念，它涉及到程序如何有效地使用和释放内存。本文主要讨论了C/C++中的内存管理，包括内存的分布、动态内存管理以及常见错误。 首先，C/C++的内存被划分为几个区域： 1. 栈：...
C++ 类类型占用内存大小一题
weixin_30780649的博客
12-31 165
1、问题描述 求解下面程序结果 #include <iostream> using namespace std; class A1 { public: int a; static int b; A1(); ~A1(); }; class A2 { public: int a; char c; ...
C/C++程序占用内存分析
写代码的小孩
11-05 1万+
首先感谢下原作者，写的真的非常明白，非常详细 1.预备知识—程序的内存分配 一个由C/C++编译的程序占用的内存分为以下几个部分 1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区（heap） — 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链
C语言 数组、字符串长度及所占内存
木有
09-02 1万+
C语言 数组、字符串长度及所占内存       今天我们的快译通软件算是告一段落啦，把最后遇到的一个问题记录下来，也算是对自己掌握知识点含糊不清，想当然的一个教训吧！     当我们把二进制索引文件的索引头加载到内存哈希表中获取所查单词在文件中的偏移量时并没出问题，但是打印单词的解释时解释后面会有乱码。后来知道是因为"\0"的问题。     #include #include int
c语言内存分配与释放 不同类别变量的内存分配和释放的区别
花有重开日，人无再少年
07-18 397
1.不同变量使用内存的区别 静态存储类别的变量：内存数量在编译时确定，程序开始执行时创建，程序结束时销毁。(static、const) 自动存储类别的变量：程序进入变量定义所在块时存在，离开块时销毁。新创建的变量按顺序加入内存，然后以相反的顺序销毁，类似栈。 动态分配内存的变量：内存在调用malloc()或相关函数时存在，调用free()后释放内存。 程序把静态对象、自动对象、动态分配的对象存储在不同的区域。 2.为什么要动态分配内存 大多数情况程序使用的数组小于100个元素，但有时程序需要100000
C++内存分类
努力打工
11-05 1919
内存分为5个区：栈，堆，自由存储区，全局/静态存储区，常量存储区。   栈区：内存由编译器再需要时自动分配和释放。通常用来存储局部变量和函数参数。（为运行函数而分配的局部变量，函数参数树，返回地址等存放在栈区）。栈运行分配内置于处理器的指令之中，效率高，但是分配的内存容量有限。   堆区：内存由new分配的内存块，他们的释放搬移其不管，有我们的应用程序区控制，一般一个new就要对应一个de...
C/C++中基本数据类型在内存中是如何存储的
JK
06-12 5999
以windows32位系统为例，先来看看各种类型的数据占用的内存大小。 类型 大小（字节） bool 1 char 1 short 2 int 4 long ...
C语言中基本类型内存
lycool_的博客
01-26 706
sizeof
[其它语言学习]《C／C-程序设计》章基本数据类型(与“变量”有关文档共36张).pptx
最新发布
11-14
总结来说，这份资料详细阐述了C/C++中的基本数据类型、变量的使用、常量的概念、标识符和保留字的规则，为初学者提供了一个全面的基础知识框架。通过学习这些内容，读者将能更好地理解和编写C/C++程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值