2. 程式人生 > >C/C++基本型別佔用記憶體總結

C/C++基本型別佔用記憶體總結

阿新 • • 發佈：2018-12-09

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

Ç程式碼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
    -----------------------------    
****在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
請按任意鍵繼續. . .
    -----------------------------    
****在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位註釋

​```C++
/*************************************************************************
    > 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() {cou

相關推薦

C/C++基本型別佔用記憶體總結

C / C ++型別佔用記憶體總結 ç語言 Ç程式碼32位註釋 /************************************************************************* > Desc

C語言基本型別

32位平臺下 C語言基本型別： 整型（int）：4 位元組 取值：-231 ~ （231 - 1） 短整型（short）：2 位元組 取值 ：-215 ~ （215 - 1） 長整型（long）：4 位元組 取值：-231 ~ （231 - 1） 浮點型 單精度型（float）：4 位元組

C# Winform應用程式佔用記憶體較大解決方法整理（轉）

原文：http://www.jb51.net/article/56682.htm 背景： 微軟的 .NET FRAMEWORK 現在可謂如火如荼了。但是，.NET 一直所為人詬病的就是“胃口太大”，狂吃記憶體，雖然微軟聲稱 GC 的功能和智慧化都很高，但是記憶體的回收

C語言基本型別與其資料儲存方式

好久沒有更新部落格了，最近對逆向十分著迷，資訊保安的知識量是真的龐大，是時候該做一波筆記了，哈哈。 看下圖，C語言資料型別分為右邊四大型別，這篇部落格重點講基本型別，因為其他型別還沒學呢~~ 整數型別 資料型別分為 char short int long 四種 char 

Dev-C++下基本型別所佔位數和取值範圍：

符號屬性     長度屬性     基本型     所佔位數     取值範圍       輸入符舉例      輸出符舉例 --            --          char         8         -2^7 ~ 2^7-1        %c 

C++：基本型別和變數

算術型別 算術型別包含整型（包括字元和布林型別）和浮點型。 主要型別：bool char wchar_t char16_t char32

C語言資料型別佔用位元組大小

在昨天的筆試的時候碰到了一個關於不同的資料型別佔用位元組大小的問題，於是就想歸納整理一下關於這方面的問題。於是就寫了一下，在Linux系統下用gcc編譯驗證了一下，以供參考。16位編譯器：char/unsigned char ：1位元組char *：2位元組short int

C++ STL容器型別的記憶體釋放

C++ 的大部分STL容器型別不會隨著生命週期的結束而自動釋放記憶體，接下來將依次對其說明：1. vector 型別經測試，直到C++11的vector型別，用clear或者erase都無法釋放記憶體，只有顯示呼叫swap：std::vector<T>.swap(

[C/C++]C++下基本型別所佔位數和取值範圍

C++下基本型別所佔位數和取值範圍：符號屬性      長度屬性      基本型      所佔位數      取值範圍   輸入符舉例       輸出符舉例--                    --           char          8      

C/C++中結構體佔用記憶體大小的計算方法

引言 結構體在C語言中雖然經常使用，但是怎麼計算一個結構體佔用多大的記憶體，很多C語言的新手都沒注意過，其實C語言的語法簡單，難就難在它更偏向於與底層，與記憶體打交道。對於嵌入式方面來說，對C語言的要求更高，因為有些硬體的記憶體並不像我們使用的電腦的記憶體那麼充裕，所以需

C#中執行緒佔用記憶體過大解決方法

專案中用到了多執行緒,而且是1000執行緒併發執行,發現記憶體佔用過高,於是對專案裡用到的物件逐個測試,發現是執行緒物件佔用記憶體 Thread[] threads = new Thread[1000]; for(int i = 0; i<threa

C#中的型別轉換大總結

使用C#一個最常見的問題便是各種型別間的轉換。我們知道，C#中的型別分為值型別和引用型別兩大類。但是，有關它們間各自轉換的細節描述在網上很少得到詳細的回答。現在，我結合搜尋到的部分資料整理如下： 1，問題 c#中型別轉換的有兩種，（）轉換和convert轉換。 我想知

【Java】int、long等基本型別佔用位元組數

基本型別 所謂的佔用位元組數，就是申請記憶體的時候所佔的空間大小 型別 位元組數 最小值 最大值 boolean 未指定，至少1位元組，僅定義為取字面值true或false - - byte 1 -

C/C++中各種 資料型別、結構體、類 佔用位元組數分析與總結

一、基本資料型別在不同編譯器下佔用位元組數比較與總結，測試過程不詳述了，直接看下錶結論！ 下表中右側總結部分是依據佔用位元組數進行著色，同一種顏色型別的資料成員佔用位元組數要麼一致，要麼具有同樣的性質，這樣比較容易理解的記憶。 佔用位元組數

5. C語言基本資料型別及構造資料型別，浮點型儲存規則及記憶體模型

  其實學習C語言的時候有一件很頭疼的事就是各種各樣的資料型別，不同的場合不同的用途不同的資料要使用不同的資料型別，那又為什麼要分出這麼多種型別呢，因為型別決定了開闢空間的大小，開闢空間的大小又決定了儲存的範圍。今天，就資料型別這個問題我們來掰扯掰扯。   C

總結：《C++ primer》中文版——第二章 變數和基本型別

2.1.基本資料型別：整型（boolean,char,int）浮點型（float(6位小數),double（10位小數）,long double（10位小數）），void(1.表示函式或過程無返回值；2.構造萬能指標型別void*，表示指向型別不限或型別不可預知的物件。) float(一個字4位元組)，do

c++primer第二章變數和基本型別

2.1 基本內建型別 2.1.1算術型別 算術型別分兩類：整型（integral type）和浮點型。 算術型別的尺寸在不同機器上有所差別。某一類所佔的位元數不同，它所能表示的資料範圍也不樣。 型別 最小尺寸

《C++ Primer》讀書筆記-第二章 變數和基本型別

   第一篇文章寫完後收到了很多同學的後臺留言，有鼓勵的，也有提出建議的，還有說錯別字的，每一條都一一回復了，當然提出建議的大都是說排版問題，現在已經換到MarkDown編輯器了，大家湊合著看就行了，肯定不影響閱讀了，至於錯別字的，哈哈，你懂就行。   &nbs

重溫C++——變數和基本型別

文章目錄 基本內建型別 複合型別 引用 指標 複合型別的宣告 指向指標的指標 引用指標的引用 const修飾符 const和引用 const和指標 指向常量的

c++可以把任意基本型別轉換為string, 類似於c 語言中的 sprintf函式

//c++中按照格式輸入輸出 類似於c 語言中的 sprintf函式 #include<iostream> #include<sstream>//std::stringstream 標頭檔案 int main() { std::string str = "高海文"