sizeof和sizeof(string)的問題

時間 2019-11-06

原文原文鏈接

今天看《程序員面試寶典》一書（爲了應付將要到來的微軟筆試），看到了sizeof(string)這個問題。在Dev C++上測試的結果是4，很不明白。上網搜了一下，獲得以下結果：html

string strArr1[]={"Trend", "Micro", "Soft"};ios

sizeof(strArr1)=12程序員

轉自：http://apps.hi.baidu.com/share/detail/30398570面試

關於sizeof(string)，今天看那本面試寶典的時候看到這個表達式，有點吃驚，書上寫着sizeof(string)=4;當時很納悶，難道分配4個字節大小的內存給string嗎？查閱了相關資料得出結論：string的實如今各庫中可能有所不一樣，可是在同一庫中相同一點是，不管你的string裏放多長的字符串，它的sizeof()都是固定的，字符串所佔的空間是從堆中動態分配的，與sizeof()無關。
sizeof(string)=4多是最典型的實現之一，不過也有sizeof()爲十二、32字節的庫實現。可是VC6.0測試後sizeof(string)=16.仍是跟編譯器有關算法

#include<iostream>
using namespace std;
void main(void)
{
string a[] = {"aaaaa","bbbb","ccc"};
int x = sizeof(a);
int y = sizeof(string);
cout << x << endl;
cout << y << endl;
}數組

運行結果：app

關於sizeof更多的用法摘自：http://hi.baidu.com/haijiaoshu/blog/item/a269f527706b910a908f9d5b.html函數

一、什麼是sizeof測試

首先看一下sizeof在msdn上的定義：spa

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.

看到return這個字眼，是否是想到了函數？錯了，sizeof不是一個函數，你見過給一個函數傳參數，而不加括號的嗎？sizeof能夠，因此sizeof不是函數。網上有人說sizeof是一元操做符，可是我並不這麼認爲，由於sizeof更像一個特殊的宏，它是在編譯階段求值的。舉個例子：

cout<<sizeof(int)<<endl; // 32位機上int長度爲4

cout<<sizeof(1==2)<<endl; // == 操做符返回bool類型，至關於 cout<<sizeof(bool)<<endl;

在編譯階段已經被翻譯爲：

cout<<4<<endl;

cout<<1<<endl;

這裏有個陷阱，看下面的程序：

int a = 0;

cout<<sizeof(a=3)<<endl;

cout<<a<<endl;

輸出爲何是4，0而不是指望中的4，3？？？就在於sizeof在編譯階段處理的特性。因爲sizeof不能被編譯成機器碼，因此sizeof做用範圍內，也就是()裏面的內容也不能被編譯，而是被替換成類型。=操做符返回左操做數的類型，因此a=3至關於int，而代碼也被替換爲：

int a = 0;

cout<<4<<endl;

cout<<a<<endl;

因此，sizeof是不可能支持鏈式表達式的，這也是和一元操做符不同的地方。

結論：不要把sizeof當成函數，也不要看做一元操做符，把他當成一個特殊的編譯預處理。

二、sizeof的用法

sizeof有兩種用法：

（1）sizeof(object)

也就是對對象使用sizeof，也能夠寫成sizeof object 的形式。例如：

（2）sizeof(typename)

也就是對類型使用sizeof，注意這種狀況下寫成sizeof typename是非法的。下面舉幾個例子說明一下：

int i = 2;

cout<<sizeof(i)<<endl; // sizeof(object)的用法，合理

cout<<sizeof i<<endl; // sizeof object的用法，合理

cout<<sizeof 2<<endl; // 2被解析成int類型的object, sizeof object的用法，合理

cout<<sizeof(2)<<endl; // 2被解析成int類型的object, sizeof(object)的用法，合理

cout<<sizeof(int)<<endl;// sizeof(typename)的用法，合理

cout<<sizeof int<<endl; // 錯誤！對於操做符，必定要加()

能夠看出，加()是永遠正確的選擇。

結論：不論sizeof要對誰取值，最好都加上()。

三、數據類型的sizeof

（1）C++固有數據類型

32位C++中的基本數據類型，也就char,short int(short),int,long int(long),float,double, long double

大小分別是：1，2，4，4，4，8, 10。

考慮下面的代碼：

cout<<sizeof(unsigned int) == sizeof(int)<<endl; // 相等，輸出 1

unsigned影響的只是最高位bit的意義，數據長度不會被改變的。

結論：unsigned不能影響sizeof的取值。

（2）自定義數據類型

typedef能夠用來定義C++自定義類型。考慮下面的問題：

typedef short WORD;

typedef long DWORD;

cout<<(sizeof(short) == sizeof(WORD))<<endl; // 相等，輸出1

cout<<(sizeof(long) == sizeof(DWORD))<<endl; // 相等，輸出1

結論：自定義類型的sizeof取值等同於它的類型原形。

（3）函數類型

考慮下面的問題：

int f1(){return 0;};

double f2(){return 0.0;}

void f3(){}

cout<<sizeof(f1())<<endl; // f1()返回值爲int，所以被認爲是int

cout<<sizeof(f2())<<endl; // f2()返回值爲double，所以被認爲是double

cout<<sizeof(f3())<<endl; // 錯誤！沒法對void類型使用sizeof

cout<<sizeof(f1)<<endl; // 錯誤！沒法對函數指針使用sizeof

cout<<sizeof*f2<<endl; // *f2，和f2()等價，由於能夠看做object，因此括號不是必要的。被認爲是double

結論：對函數使用sizeof，在編譯階段會被函數返回值的類型取代，

四、指針問題

考慮下面問題：

cout<<sizeof(string*)<<endl; // 4

cout<<sizeof(int*)<<endl; // 4

cout<<sizof(char****)<<endl; // 4

能夠看到，不論是什麼類型的指針，大小都是4的，由於指針就是32位的物理地址。

結論：只要是指針，大小就是4。（64位機上要變成8也不必定）。

順便唧唧歪歪幾句，C++中的指針表示實際內存的地址。和C不同的是，C++中取消了模式之分，也就是再也不有small,middle,big,取而代之的是統一的flat。flat模式採用32位實地址尋址，而再也不是c中的 segment:offset模式。舉個例子，假若有一個指向地址 f000:8888的指針，若是是C類型則是8888(16位, 只存儲位移，省略段)，far類型的C指針是f0008888(32位，高位保留段地址，地位保留位移),C++類型的指針是f8888(32位，至關於段地址*16 + 位移，但尋址範圍要更大)。

五、數組問題

考慮下面問題：

char a[] = "abcdef";

int b[20] = {3, 4};

char c[2][3] = {"aa", "bb"};

cout<<sizeof(a)<<endl; // 7

cout<<sizeof(b)<<endl; // 20*4=80

cout<<sizeof(c)<<endl; // 6

數組a的大小在定義時未指定，編譯時給它分配的空間是按照初始化的值肯定的，也就是7。c是多維數組，佔用的空間大小是各維數的乘積，也就是6。能夠看出，數組的大小就是他在編譯時被分配的空間，也就是各維數的乘積*數組元素的大小。

結論：數組的大小是各維數的乘積*數組元素的大小。

這裏有一個陷阱：

int *d = new int[10];

cout<<sizeof(d)<<endl; // 4

d是咱們常說的動態數組，可是他實質上仍是一個指針，因此sizeof(d)的值是4。

再考慮下面的問題：

double* (*a)[3][6];

cout<<sizeof(a)<<endl; // 4

cout<<sizeof(*a)<<endl; // 72

cout<<sizeof(**a)<<endl; // 24

cout<<sizeof(***a)<<endl; // 4

cout<<sizeof(****a)<<endl; // 8

a是一個很奇怪的定義，他表示一個指向 double*[3][6]類型數組的指針。既然是指針，因此sizeof(a)就是4。

既然a是執行double*[3][6]類型的指針，*a就表示一個double*[3][6]的多維數組類型，所以sizeof(*a)=3*6*sizeof(double*)=72。一樣的，**a表示一個double*[6]類型的數組，因此sizeof(**a)=6*sizeof(double*)=24。***a就表示其中的一個元素，也就是double*了，因此sizeof(***a)=4。至於****a，就是一個double了，因此sizeof(****a)=sizeof(double)=8。

六、向函數傳遞數組的問題。

考慮下面的問題：

#include <iostream>

using namespace std;

int Sum(int i[])

{

int sumofi = 0;

for (int j = 0; j < sizeof(i)/sizeof(int); j++) //實際上，sizeof(i) = 4

{

sumofi += i[j];

}

return sumofi;

}

int main()

{

int allAges[6] = {21, 22, 22, 19, 34, 12};

cout<<Sum(allAges)<<endl;

system("pause");

return 0;

}

Sum的本意是用sizeof獲得數組的大小，而後求和。可是實際上，傳入自函數Sum的，只是一個int 類型的指針，因此sizeof(i)=4，而不是24，因此會產生錯誤的結果。解決這個問題的方法使是用指針或者引用。

使用指針的狀況：

int Sum(int (*i)[6])

{

int sumofi = 0;

for (int j = 0; j < sizeof(*i)/sizeof(int); j++) //sizeof(*i) = 24

{

sumofi += (*i)[j];

}

return sumofi;

}

int main()

{

int allAges[] = {21, 22, 22, 19, 34, 12};

cout<<Sum(&allAges)<<endl;

system("pause");

return 0;

}

在這個Sum裏，i是一個指向i[6]類型的指針，注意，這裏不能用int Sum(int (*i)[])聲明函數，而是必須指明要傳入的數組的大小，否則sizeof(*i)沒法計算。可是在這種狀況下，再經過sizeof來計算數組大小已經沒有意義了，由於此時大小是指定爲6的。

使用引用的狀況和指針類似：

int Sum(int (&i)[6])

{

int sumofi = 0;

for (int j = 0; j < sizeof(i)/sizeof(int); j++)

{

sumofi += i[j];

}

return sumofi;

}

int main()

{

int allAges[] = {21, 22, 22, 19, 34, 12};

cout<<Sum(allAges)<<endl;

system("pause");

return 0;

}

這種狀況下sizeof的計算一樣無心義，因此用數組作參數，並且須要遍歷的時候，函數應該有一個參數來講明數組的大小，而數組的大小在數組定義的做用域內經過sizeof求值。所以上面的函數正確形式應該是：

#include <iostream>

using namespace std;

int Sum(int *i, unsigned int n)

{

int sumofi = 0;

for (int j = 0; j < n; j++)

{

sumofi += i[j];

}

return sumofi;

}

int main()

{

int allAges[] = {21, 22, 22, 19, 34, 12};

cout<<Sum(i, sizeof(allAges)/sizeof(int))<<endl;

system("pause");

return 0;

}

七、字符串的sizeof和strlen

考慮下面的問題：

char a[] = "abcdef";

char b[20] = "abcdef";

string s = "abcdef";

cout<<strlen(a)<<endl; // 6，字符串長度

cout<<sizeof(a)<<endl; // 7，字符串容量

cout<<strlen(b)<<endl; // 6，字符串長度

cout<<sizeof(b)<<endl; // 20，字符串容量

cout<<sizeof(s)<<endl; // 12, 這裏不表明字符串的長度，而是string類的大小

cout<<strlen(s)<<endl; // 錯誤！s不是一個字符指針。

a[1] = '\0';

cout<<strlen(a)<<endl; // 1

cout<<sizeof(a)<<endl; // 7，sizeof是恆定的

strlen是尋找從指定地址開始，到出現的第一個0之間的字符個數，他是在運行階段執行的，而sizeof是獲得數據的大小，在這裏是獲得字符串的容量。因此對同一個對象而言，sizeof的值是恆定的。string是C++類型的字符串，他是一個類，因此sizeof(s)表示的並非字符串的長度，而是類string的大小。strlen(s)根本就是錯誤的，由於strlen的參數是一個字符指針，若是想用strlen獲得s字符串的長度，應該使用sizeof(s.c_str())，由於string的成員函數c_str()返回的是字符串的首地址。實際上，string類提供了本身的成員函數來獲得字符串的容量和長度，分別是Capacity()和Length()。string封裝了經常使用了字符串操做，因此在C++開發過程當中，最好使用string代替C類型的字符串。

八、從union的sizeof問題看cpu的對界

考慮下面問題：（默認對齊方式）

union u

{

double a;

int b;

};

union u2

{

char a[13];

int b;

};

union u3

{

char a[13];

char b;

};

cout<<sizeof(u)<<endl; // 8

cout<<sizeof(u2)<<endl; // 16

cout<<sizeof(u3)<<endl; // 13

都知道union的大小取決於它全部的成員中，佔用空間最大的一個成員的大小。因此對於u來講，大小就是最大的double類型成員a了，因此sizeof(u)=sizeof(double)=8。可是對於u2和u3，最大的空間都是char[13]類型的數組，爲何u3的大小是13，而u2是16呢？關鍵在於u2中的成員int b。因爲int類型成員的存在，使u2的對齊方式變成4，也就是說，u2的大小必須在4的對界上，因此佔用的空間變成了16（最接近13的對界）。

結論：複合數據類型，如union，struct，class的對齊方式爲成員中對齊方式最大的成員的對齊方式。

順便提一下CPU對界問題，32的C++採用8位對界來提升運行速度，因此編譯器會盡可能把數據放在它的對界上以提升內存命中率。對界是能夠更改的，使用#pragma pack(x)宏能夠改變編譯器的對界方式，默認是8。C++固有類型的對界取編譯器對界方式與自身大小中較小的一個。例如，指定編譯器按2對界，int類型的大小是4，則int的對界爲2和4中較小的2。在默認的對界方式下，由於幾乎全部的數據類型都不大於默認的對界方式8（除了long double），因此全部的固有類型的對界方式能夠認爲就是類型自身的大小。更改一下上面的程序：

#pragma pack(2)

union u2

{

char a[13];

int b;

};

union u3

{

char a[13];

char b;

};

#pragma pack(8)

cout<<sizeof(u2)<<endl; // 14

cout<<sizeof(u3)<<endl; // 13

因爲手動更改對界方式爲2，因此int的對界也變成了2，u2的對界取成員中最大的對界，也是2了，因此此時sizeof(u2)=14。

結論：C++固有類型的對界取編譯器對界方式與自身大小中較小的一個。

九、struct的sizeof問題

由於對齊問題使結構體的sizeof變得比較複雜，看下面的例子：(默認對齊方式下)

struct s1

{

char a;

double b;

int c;

char d;

};

struct s2

{

char a;

char b;

int c;

double d;

};

cout<<sizeof(s1)<<endl; // 24

cout<<sizeof(s2)<<endl; // 16

一樣是兩個char類型，一個int類型，一個double類型，可是由於對界問題，致使他們的大小不一樣。計算結構體大小能夠採用元素擺放法，我舉例子說明一下：首先，CPU判斷結構體的對界，根據上一節的結論，s1和s2的對界都取最大的元素類型，也就是double類型的對界8。而後開始擺放每一個元素。

對於s1，首先把a放到8的對界，假定是0，此時下一個空閒的地址是1，可是下一個元素d是double類型，要放到8的對界上，離1最接近的地址是8了，因此d被放在了8，此時下一個空閒地址變成了16，下一個元素c的對界是4，16能夠知足，因此c放在了16，此時下一個空閒地址變成了20，下一個元素d須要對界1，也正好落在對界上，因此d放在了20，結構體在地址21處結束。因爲s1的大小須要是8的倍數，因此21-23的空間被保留，s1的大小變成了24。

對於s2，首先把a放到8的對界，假定是0，此時下一個空閒地址是1，下一個元素的對界也是1，因此b擺放在1，下一個空閒地址變成了2；下一個元素c的對界是4，因此取離2最近的地址4擺放c，下一個空閒地址變成了8，下一個元素d的對界是8，因此d擺放在8，全部元素擺放完畢，結構體在15處結束，佔用總空間爲16，正好是8的倍數。

這裏有個陷阱，對於結構體中的結構體成員，不要認爲它的對齊方式就是他的大小，看下面的例子：

struct s1

{

char a[8];

};

struct s2

{

double d;

};

struct s3

{

s1 s;