#include <iostream>

class SuicideSample {
        public:
                SuicideSample() { std::cout << "ctor." << std::endl; }
                ~SuicideSample() { std::cout << "dtor." << std::endl; }
                void DoIt( void ) { 
                        delete this;
                }
};

int main( int argc, char* argv[] )
{
        SuicideSample* obj=new SuicideSample();
        obj->DoIt();
        // of course, object can kill itself, but if you try to kill it again
        // program will crash.
        //delete obj;
        return 0;
}

#include "SkTypes.h"
#include "SkRefCnt.h"
#include "SkBitmap.h"
#include "SkDevice.h"
#include "SkPaint.h"
#include "SkRect.h"
#include "SkMallocPixelRef.h"

class FrameBufferAllocator: public SkBitmap::Allocator
{
    public:
	FrameBufferAllocator();
	virtual ~FrameBufferAllocator();
        virtual bool allocPixelRef(SkBitmap*, SkColorTable*);
    private:
        char* m_addr;
        int fd;
};

FrameBufferAllocator::FrameBufferAllocator()
{
}

FrameBufferAllocator::~FrameBufferAllocator()
{
  // munmap framebuffer pointer.
  // close the framebuffer device we opened
}

bool FrameBufferAllocator::allocPixelRef(SkBitmap* dst, SkColorTable* ctable)
{
    size_t size = dst->getSize();

    // open framebuffer
    fd = open( "/dev/fb0", O_RDWR );

    // setup framebuffer device via ioctl.

    // mmap framebuffer
    m_addr = (char *)mmap(0, screensize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

    // call original procedures in HeapAllocator::
    dst->setPixelRef(new SkMallocPixelRef(m_addr, size, ctable))->unref();
    dst->lockPixels();
    return true;
}

	bitmap.allocPixels( new FrameBufferAllocator, NULL );

i && (j=100);

if(i) j=100;

bool Write( uint16_t address, uint16_t value ) {
	int res=0;
	struct i2c_rdwr_ioctl_data msg_rdwr;
	char msgbuf0[I2C_SMBUS_BLOCK_MAX+4];
	char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
	struct i2c_msg msg[1] = { { _address, 0, 4, msgbuf0 } };
	uint8_t* pAddr = (uint8_t*)&address;
	uint8_t* pValue = (uint8_t*)&value;

	msg_rdwr.msgs = &msg[0];
	msg_rdwr.nmsgs = 1; // write // read = 2

	// 因為 little endian，所以要作調整
	msgbuf0[0] = *(pAddr+1);
	msgbuf0[1] = *(pAddr+0);
	msgbuf0[2] = *(pValue+1); // (1)
	msgbuf0[3] = *(pValue+0);

	res = ioctl( _file, I2C_RDWR, &msg_rdwr );
	usleep(10000);

	return true;
}
bool Read( uint16_t address, uint16_t& data ) {
	int res=0;
	struct i2c_rdwr_ioctl_data msg_rdwr;
	char msgbuf0[I2C_SMBUS_BLOCK_MAX+2];
	char msgbuf1[I2C_SMBUS_BLOCK_MAX+2]={0};
	struct i2c_msg msg[2] = { { _address, 0, 2, msgbuf0 },
	                          { _address, I2C_M_RD, 2, msgbuf1 }
	                        };
	uint8_t* pAddr = (uint8_t*)&address;

	msg_rdwr.msgs = &msg[0];
	msg_rdwr.nmsgs = 1; // read = 2
	// 因為 little endian，所以要作調整
	msgbuf0[0] = *(pAddr+1);
	msgbuf0[1] = *(pAddr+0);
	res = ioctl( _file, I2C_RDWR, &msg_rdwr );
	usleep(10000);

	msg_rdwr.msgs = &msg[1];
	msg_rdwr.nmsgs = 1; // read = 2
	res = ioctl( _file, I2C_RDWR, &msg_rdwr ); #ifdef DEBUG
	data = msgbuf1[0] | (msgbuf1[1] << 8);

	return true;
}
int main( int argc, char* argv[] )
{
	int data=0;

	Read( 0x17, data );
	printf("data=%d\n", data );

	// 這邊其實不好，實際上寫 0x0052會比較清楚，這邊必須寫 0x5200，因為我在 Write() 裡有作對調，參看(1)
	Write( 0x00, 0x5200 );  
}

#include <gdk/gdkkeysyms.h> // 定義按鍵值的 header

static gboolean press_event( GtkWidget* widget, GdkEventButton* event, gpointer data )
{
	if( debug )
		g_print("press_event: x=%f y=%f button=%d\n", event->x, event->y, event->button );

	if( event->button==1 )  { // left
	}
}

static gboolean key_event( GtkWidget* widget, GdkEventKey* event )
{
	if( debug )
		g_print( "event->keyval=%d event->state=%d\n", event->keyval, event->state );
	switch (event->keyval) {
		// 省略...
	}
	return TRUE;
}

int main( int argc, char* argv[] )
{
// 省略一萬行...
	g_signal_connect( drawing_area, "button_press_event", G_CALLBACK( press_event ), NULL );
	g_signal_connect( drawing_area, "key_press_event", G_CALLBACK( key_event ), NULL );

	// 要接收 button_press_event 跟 key_press_event 喔~
	gtk_widget_set_events( drawing_area, gtk_widget_get_events(drawing_area) | GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK );
// 省略兩萬行...
}

1. new(storage) Person() 實際上是 new 在 storage 這塊空間裡面，所以之後如果呼叫 delete，會出錯。
2. 如果不累加 storage 的話，會把之前配置的空間覆蓋掉。
3. malloc() 可以用 shmget()、shmat() 代替，沒有問題。
4. 以上面的例子，std::string 會配置一塊空間來放字串，這塊空間並不在 storage 裡面，使用時要注意。如果要這樣用，應該要再取代掉 STL allocator 的機制。

1. 在專案根目錄的 CMakeLists.txt 加上 ENABLE_TESTING()
2. 在你 test 程式所在目錄的 CMakeLists.txt 加上 add_test( 測試名稱 執行檔名字 [參數1] [參數2] ... )
3. 測試程式在錯誤發生時呼叫 exit() 並傳入非 0 值，正常結束的話，則呼叫 exit(0)。
4. 大功告成以後，先刪除 CMakeCache.txt，然後用 cmake 重新產生 Makefile，接下來就可以用 make && make test 來進行測試了。
5. make test 是進行所有測試，只想進行某幾項測試的話，可以查看 ctest 的 -R, -E, -I 這幾個選項的說明。-R 是用 regular expression 找特定名稱的測試項目，-E 則是相反，排除掉特定名稱的測試項目，-I 是指定項目號碼，表示進行指定項目的測試。

1. 打開 visual studio 2005 命令提示字元
2. 切換到你的 boost目錄 下，這裡假設為 c:\boost_1_36_0
3. 執行 bjam --build-dir="c:\boost_1_36_0\build" --toolset=msvc-8.0 --build-type=complete --with-regex stage，就可以只編譯 boost::regex.
4. 編譯會需要一陣子，編譯好的檔案就會放在 c:\boost_1_36_0\build\boost\bin.v2\libs\regex\ 下

register n = (count + 7) / 8; /* count > 0 assumed */

switch (count % 8)
{
case 0: do { *to = *from++;
case 7: *to = *from++;
case 6: *to = *from++;
case 5: *to = *from++;
case 4: *to = *from++;
case 3: *to = *from++;
case 2: *to = *from++;
case 1: *to = *from++;
} while (–n > 0);
}

• Duff's device


• http://www.lysator.liu.se/c/duffs-device.html

#include <stdio.h>
#include <setjmp.h>

jmp_buf setjmp_buffer;

int
main( int argc, char* argv[] )
{
if( setjmp( setjmp_buffer ) == 0 )
{
// do something
printf("longjmp!!\n");
longjmp( setjmp_buffer, 1 ); // 用 0 的話, setjmp() 就會收到 0, 那麼可能會無窮回圈
}
else
{
// do something
printf("after longjmp.\n");
}
}

int exception_id;
if( ( exception_id = setjmp( setjmp_buffer ) ) == 0 ) // try
{
// do something
longjmp( setjmp_buffer, 1 ); // throw
}
else
{
if( exception_id == 1 ) // catch( 1 )
{
}
if( exception_id == 2 ) // catch( 2 )
{
}
// ....
}
// 之後,就是 finally...

wchar_t* myString=L"music is wonderful!!";
wprintf( L"%s\n", myString );

wchar_t* myString=L"music is wonderful!!";
wprintf( L"%ls\n", myString );

在設計上,可以將 /etc/localtime symbolic link 到 /usr/share/zoneinfo 下的 zone file. 藉著取得真實路徑的函數readlink(),就可以得知是哪裡的 timezone.

同 1, 可以用 symbolic link 的方式來設定

如果有設定 TZ 環境變數,那麼 /etc/localtime 將會失效.
TZ 有特定格式,需要查一下,大多的 embedded system 都是直接利用 TZ 環境變數,而不使用 zone file.

可以直接開啟 /usr/share/zoneinfo/zone.tab 來取得列表.
此檔共有四欄: code, coordinates, TZ, comments.
照慣例,以 # 開始的該列為註解.
比較需要用到的兩個欄位: TZ 與 comments.

預設值可以直接指向 /usr/share/zoneinfo/GreenWich 表示為格林威治標準時間

回覆日期:2003年2月20日 上午 03:38

你的程式寫的邏輯不對。

> bool operator==( const myInt& l, const myInt& r) {
> bool operator>( const myInt& l, const myInt& r) {
> bool operator<( const myInt& l, const myInt& r) {

這三個都沒有完整判斷。sort 的時候，要求 class 需定義 operator<，
而 operator< 在什麼時候應該傳回 0, 什麼時候傳回 正值，什麼時候傳回負值，有一定的規則。

問題不是出在你指的地方，而在這裡。

-- jjhou

----- Original Message -----
寄件者: "晏仁"
收件者:
傳送日期: 2002年10月8日 PM 11:07
主旨: 請教 STL sort() 的問題


> Dear 侯sir:
>
> 冒昧請教,以下是程式,而問題在最後面~
>
> #include <iostream>
> #include <algorithm>
> #include <vector>
>
> using namespace std;
>
> class myInt {
> protected:
>   int id;
> public:
>   myInt():id(0) {};
>   explicit myInt( int i ):id(i) {};
>   myInt( const myInt& i ):id(i.id) { };
>   int getId( void ) const {
>     return id;
>   }
>   myInt& operator=( myInt& i) {
>     id=i.id;
>     return *this;
>   }
>   myInt& operator=( int i ) {
>     id=i;
>     return *this;
>   }
>   myInt& operator*() { return *this; }
>   myInt* operator->() { return this; }
>   friend bool operator==( const myInt& l, const myInt& r );
>   friend bool operator<( const myInt& l, const myInt& r );
>   friend bool operator>( const myInt& l, const myInt& r );
> };
>
> bool operator==( const myInt& l, const myInt& r) {
>   if( l.getId() == r.getId() )
>     return true;
> }
>
> bool operator>( const myInt& l, const myInt& r) {
>   if( l.getId() > r.getId() )
>     return true;
> }
> bool operator<( const myInt& l, const myInt& r) {
>   if( l.getId() < r.getId() )
>     return true;
> }
>
> class myIntCompare {
> public:
>   int operator()( myInt aa, myInt bb ) {
>     if( aa.getId() > bb.getId() )
>       return 1;
>     if( aa.getId() == bb.getId() )
>       return 0;
>     if( aa.getId() < bb.getId() )
>       return -1;
>   }
> };
>
> int
> main( int argc, char* argv[] ) {
>   const int COUNTS=10000;
>   typedef vector< myInt > intVector_t;
>   intVector_t intVector;
>   int i;
>
>   /**
>    * 下面的兩行 code 會導致 segmentation fault,這就是我要問的問題!!
>    * for( i=COUNTS;i>=0;--i )
>    * intVector.push_back( myInt(i) );
>    */
>   intVector.reserve( COUNTS );
>   for( i=COUNTS; i>=0; --i )
>     intVector[i]=i;
>
>   // 以下兩種寫法都可以
>   sort( intVector.begin(), intVector.end(), myIntCompare() );
>   //sort( intVector.begin(), intVector.end() );
>
>   for( i=0; i<=COUNTS; ++i )
>     cout << intVector[i].getId() << endl;
> }
>
> 為什麼把
>   intVector.reserve( COUNTS );
>   for( i=COUNTS; i>=0; --i )
>     intVector[i]=i;
>
> 改成
>   for( i=COUNTS;i>=0;--i )
>     intVector.push_back( myInt(i) );
>
> 編譯後再執行
> 就會發生 segmentation fault 的問題呢??
> 真的是很奇怪
> 我知道 vector 在配置的時候會先預留一塊記憶體
> 在 push_back() 的時候,如果發現不夠大,會自動重新配置,
> 並把原來的內容搬到新的地方去.
> 我想可能是重新配置的問題~~
> 但卻不知道真正的原因是什麼?
> 希望侯 sir 能給我一些方向,讓我下手去找出答案~
>
> 喔,對了,我的環境是 linux g++ 2.96.
>
> With Best Regards.

於是就寫了一個小程式來測試一下

#include <iostream>
#include <string>

int
main(int argc, char* argv[] ) {
  wstring ws;
  ws=wstring("This is a test");
  cout << ws << endl;
}

但卻遭遇編譯失敗.

在看過 C++ 的 header 之後
發覺他把 wstring 的部分給 remark 起來了
所以我利用 grep 去找尋相關的部分
並做了一些修正如下:

1. 將 string 中的 wstring 前頭的註解拿掉
2. std/straits.h 134行 #if 0 改為 #if 1 std/cpp_type_traits.h 130行 #if 0 改為 #if 1
3. 在 #include <string> 之前,要先 定義 __USE_ISOC99 或 __USE_UNIX98 (但#define __USE_UNIX98 會使得 pthread 有誤) 然後再 #include <cwchar> #include <cwctype>

結果呢
還是不行
真是傷腦筋~~

也許是因為雖然我用的是 gcc3 ,但header檔卻是 2.96 的緣故吧~

#include <iostream>

#include <string>

#include <vector>

class node {

public:

 node();

 node( string s );

 node( char* s );

 ~node();

private:

 string m_string;

};

node::node() {

 m_string="";

 cout << "initialize " << m_string << endl;

}

node::node(string s):m_string(s) {

  cout << "initialize " << m_string << endl;

}

node::node(char* s):m_string(s) {

 cout << "initialize " << m_string << endl;

}

node::~node() {

 cout << "destroy " << m_string << endl;

}

int main(void) {

 vector<node> vector_test1;

 vector<node*> vector_test2;

 cout << "Non-Pointer Version" << endl;

 vector_test1.push_back( node("test1") );

 vector_test1.push_back( node("test2") );

 vector_test1.push_back( node("test3") );

 vector_test1.push_back( node("test4") );

 vector_test1.push_back( node("test5") );

 vector_test1.push_back( node("test6") );

 vector_test1.push_back( node("test7") );

 vector_test1.push_back( node("test8") );

 vector_test1.push_back( node("test9") );

 vector_test1.push_back( node("test10") );

 cout << endl << "Pointer Version" << endl;

 vector_test2.push_back( new node("test1") );

 vector_test2.push_back( new node("test2") );

 vector_test2.push_back( new node("test3") );

 vector_test2.push_back( new node("test4") );

 vector_test2.push_back( new node("test5") );

 vector_test2.push_back( new node("test6") );

 vector_test2.push_back( new node("test7") );

 vector_test2.push_back( new node("test8") );

 vector_test2.push_back( new node("test9") );

 vector_test2.push_back( new node("test10") );

}

Non-Pointer Version

initialize test1

destroy test1

initialize test2

destroy test1

destroy test2

initialize test3

destroy test1

destroy test2

destroy test3

initialize test4

destroy test4

initialize test5

destroy test1

destroy test2

destroy test3

destroy test4

destroy test5

initialize test6

destroy test6

initialize test7

destroy test7

initialize test8

destroy test8

initialize test9

destroy test1

destroy test2

destroy test3

destroy test4

destroy test5

destroy test6

destroy test7

destroy test8

destroy test9

initialize test10

destroy test10

Pointer Version

initialize test1

initialize test2

initialize test3

initialize test4

initialize test5

initialize test6

initialize test7

initialize test8

initialize test9

initialize test10

destroy test1

destroy test2

destroy test3

destroy test4

destroy test5

destroy test6

destroy test7

destroy test8

destroy test9

destroy test10

• C++ Object Model
• 繼承
• 虛擬繼承
• class 與 struct
• 多型

C++ Object Model

一般來說有三種實作方式:

1.Simple: 一個Object內有一個 slot table, table 中各 slot 指向一個 member.

2.Table: 把 member 和 function 抽出來為 兩個 table, 物件內含一指標指向這兩個 table, 而 function table 又指向各 function.

3.目前一般常見 C++ Compiler 所採用的物件模型, 則是將 member 放在物件中,物件內含一指標指向 function table, 而 static member 則另外存放於 heap 中.

繼承

早期,直接把 base class member 含括到 derived class, 較快; 但若 base class 變更,會造成 derived class 需重新 compile.

2.0 規格以後,為有關聯的 virtual base class 加上指標:

1. 導入 virtual base class table
2. 擴充現有的 virtual table

簡單的說就是在衍生類別中加上指標指回 base class 的 member 和 function.

虛擬繼承

亦可指定 virtual, 如 iostream

class istream: virtual public ios {...};
class ostream:virtual public ios {...};

此情況下, base class 不管在繼承串列中被衍生幾次,均只存在一個實體,上例中, ios 將只存在一個.

class 和 struct

class 和 struct 幾乎相同,但仍然請依照需要乖乖使用.

多型

只有透過 pointer 或 reference 的間接處理,才支援多型.

摘要:

nonstatic member function

virtual member function

static member function

virtual member function(單一繼承)

多重繼承

函式的效能

Point-to-member functions

inline function

nonstatic member function

nonstatic member function 實際上會被內化為 nonmember 的形式,步驟如下:

1. 改寫函式的 signature 以安插一個額外的參數,用以提供一個存取管道,使 class object 得以將此函式喚起.額外參數就是 this.
2. 將對 "nonstatic data member 的存取動作" 改經由 this 指標存取.
3. 改寫成一個外部函式,將函式名稱經過 "mangling" 處理,以成為一個獨一無二的語彙.

名稱的特殊處理 (Name mangling)

一般而言, member 的名稱後面會被加上 class 名稱. 若你宣告 extern "C", 就會壓抑 nonmember functions 的 "mangling" 效果. 此 mangling 的動作, 各家 compiler 實作方式不同.

virtual member functions

若 ptr->normalize(); 

則會被轉化為

(*ptr->vptr[1])(ptr);

其中:

• vptr 表示由 compiler 產生的指標,指向 virtual table, 其名稱也會被 "mangled", 因為在一個複雜的衍生體系中,可能存在多個 vptrs.
• 1 是 virtual tabe slot 的索引值.
• 第二個 ptr 表示 this 指標.

若宣告為 inline, 則會被 compiler 當作一般 nonstatic member function 一樣地決議,提供極大的效率利益.

static member function

一般建議把 static data member 宣告為 nonpublic, 並提供一個或多個 member functions 來存取之.

主要特性: 沒有 this 指標.

次要特性: 他不能直接存取其 class 中的 nonstatic members; 他不能被宣告為 const, volatile, 或 virtual; 他不需要經由 class object 才被喚起.

如果取一個 static member function 的位址, 將獲得其在記憶體中的位置,其位址的型別並不是一個 "指向 class member function 的指標", 而是一個 "nonmember 函式指標".即

&Point3D::object_count();

會得到

 unsigned int (*)();

而非

 unsigned int (Point3D:*)();

差不多等同於 nonmember function.

p.s. object_count 原型宣告為

unsigned int
Point3D::
object_count() {
	return _object_count;
}

virtual member function(單一繼承)

單一繼承一般是在每個多型的 class object 身上增加 2 個 member:

1. 一個字串或數字,表示 class 型別.
2. 一個指標指向某表格,表格中持有程式的 virtual functions 的執行時期位址.為了找到函式位址,每個 virtual function 被指派一個表格索引值.

這些工作都由 compiler 完成. 執行時期要做的只是在特定的 virtual table slot 中啟動 virtual function.

圖解. 若 Point3D 繼承 Point2D 繼承 Point, 那麼個別的 virtual table 就可能是

於是當

Point *ptr;
ptr=new Point3D();
ptr->z();

compiler 可以把該呼叫轉化為

(*ptr->vptr[4])(ptr);

多重繼承

在多重繼承中支援 virtual function,其複雜度圍繞在第二個及後繼的 base class 上,以及"必須在執行時期調整 this 指標"上.

即後繼的 class 會有多個 virtual table.

將後繼的物件位址指定給一個 base1 指標或 base2 指標時, virtual table 就要視指標的型態作切換,以免呼叫到錯誤的函數.

效率若依照原始 c++ 模型,會變的不好,但這方面各家 compiler 會利用 thunk 或 address points 策略來改善.

虛擬繼承下的 virtual functions

實作上,同樣要調整 this 指標,很複雜,效率也不一定較好,建議不要在一個 virtual base class 中宣告 nonstatic data members.

函式的效能

inline > (nonmember friend=static member=nonstatic member) > virtual member > virtual member(多重繼承) > virtual member(虛擬繼承)

virtual member 在層數越多的狀況下,其執行時間也成正比增加.

Point-to-Member functions

double (Point::*pmf)();
double (Point::*coord)()=&Point::x; //初始
coord=&Point::y; //或是這樣初始

於是可以

(origin.*coord)();

或

(ptr->*coord)();

這樣用.

實際上則會轉化為

(coord)(&origin);

和

(coord)(ptr);

支援"指向 virtual member functions"的指標

考慮如下片段(假設 z 為 virtual function)

float (Point::*pmf)()=&Point::z;
Point *ptr=new Point3D;
ptr->z(); //ok
(ptr->*pmf)(); //仍然 ok

compiler 實作上,必須定義 pmf, 使他能持有兩種數值,並且其數值能區分其意義.

多重繼承的狀況:

stroustrup 利用 union 來處理

struct __mptr {
	int delta;
	int index; //處理 virtual table 索引,不指時為 -1
	union {
		ptrfunc faddr;
		int v_offset; //處理 nonvirtual member function
	};
};

於是

(ptr->*pmf)();

會變成

(pmf.index<0)?
	(*pmf.faddr)(ptr):
	(*ptr->vptr[pmf.index](ptr));

Microsoft 以 vcall thunk 來作檢查,避免浪費檢查的時間,但副作用是,當傳遞一個不變值的指標給 member function 時,需要產生暫時性的物件.

效率:同樣地,不牽涉到"虛擬"+"多重"情況的,效率較佳.

inline function

一般處理時,有兩個階段:

1. 分析函式,若因某些問題(複雜度過高,建構問題...等)被判斷不可 inline, 則會轉為 static 函式,並在被編譯模組中產生對應的函式定義.
2. 真正的 inline function 擴展動作,是在呼叫的那一點上,這會帶來參數的求值動作及暫時性物件的管理.

通常需進入 assembler 中,才能得知是否真實現了 inline

形式參數擴展的情況大致如下:

inline int min(int i, int j) {
	return i<j?i:j;
}
int
main() {
	int minval;
	int val1=1024,val2=2048;
	minval=min(val1,val2);		//minval=val1<val2?val1:val2;
	minval=min(1024,2048);		//minval=1024;
	minval=min(foo(),bar()+1);	//int t1,t2;
								//minval=(t1=foo()),(t2=bar()+1),t1<t2?t1:t2;

區域變數的情況

若

inline int
min(int i, int j) {
	int minval=i<j?i:j;
	return minval;
}
int local_var;
int minval;
...
minval=min(val1,val2);

則可能會代換為

int local_var;
int minval;
int __min_lv_minval;
minval=(__min_lv_minval=val1<val2?val1:val2),__min_ln_minval;

inline 函式中的區域變數再加上有副作用的參數,可能會導致大量暫時性物件的產生.並且使得程式大小暴增.避免過於複雜的 inline 函式,以免 compiler 無法擴展開來.

摘要

• static data member
• 物件的大小
• data member 的佈局
• data member 的存取
• 繼承與 data member
• 指向 data members 的指標

static data member

static data member 永遠在 global data segment, 不影響 class object 的大小.

物件的大小

class object 的大小有可能因為 compiler 實作物件模型的方式不同而有不同,原因:

1. compiler自動加上額外 data member, 以支援某些語言特性.
2. alignment 邊界調整需要(比如: char 為配合機器特性而以 long 存放)

雖然目前 C++ compiler 已經非常進步,但早期會有兩種程式寫作防禦方格,以防止資料繫結錯誤.

1. 把 data member 寫在 class 的開頭.
2. inline function 移到 class 宣告之後,而不在宣告區裡面實作, 如:

extern int x;
class Point3D {
private:
	float x,y,z;
public:
	float X() const {return x;} 	//到底傳回哪個 x 呢?
	float getX() const; 			//早期若不這樣寫,會造成資料繫結到上面那個 x
};
inline float
Point3D::
getX() const {
	return x;
}

data member 的佈局

data member 實際的存放(佈局)

注意:各 data member 再實際存放時不一定連續.

如:

class Point3D {
	float x;
	float y;
	float z;
};

x,y,z 不一定是連續的,有可能為了要補 alignment 或因compiler 的調整為 y,x,z, 主要原因是 C++ Standard 對此採放任態度.一般而言,仍是連續的.

data member 的存取

當 member 被宣告為 static 時,實際上和一般變數存取一樣,因為 static member 存放在 class 之外,不需要再透過 class 去存取. 若不是宣告為 static, 事實上,都會透過一個隱含的 class object (this) 完成,也就是類似這樣

Point3D
Point3D:translate( Point3D* this, const Point3D &pt) {
	this->x+=pt.x;
	this->y+=pt.y;
	this->z+=pt.z;
}

若在程式中對 data member 做存取,如:

origin.y=0.0;

那麼實際上將等於

&origin+(&Point3D::y-1)

指向 data member 的指標,其 offset 值總是被加上 1, 這樣子 compiler就能需分出"一個指向 data member 的指標,用以指出 class 的第一個 member"和"一個指向 data member 的指標,未指向任何 member"的情況.(那就是上面為什麼要 -1的原因).

繼承與 data member

在沒有 virtual function 的狀況下,和 struct 相同.原本是獨立不相干的 class 湊成 type / subtype, 並有繼承關係(如 Point2D -> Point3D), 經驗不足的人可能會重複設計一些相同動作的函式,以 constructor 和 operator += 為例, 可以做成 inline. 另外把一個 class 分解為二層或更多層,有可能會為了"表現 class 體系之抽象化"而膨脹所需空間.如: parent 為兩個 int, child 為一個 char, grandchild 為一個 char, compiler 會為了 alignment 而填補空間.

加上 virtual function 後,將需要導入 vptr, 並在每個函式做 vptr 的處理, 解構時也要把 vptr 抹消,一般而言, vptr 放在 class 的最後面,但 visual c++ 放在最前面,主要是為了繼承的效率問題.

class 若內含一個或多個 virtual base class subobjects, 將會分割為二部分:一個不變區域和一個共享區域,不變區域的資料,不管後繼如何衍化,總擁有固定的 offset(自 object 的起頭算起), 所以可以直接存取,至於共享區域,表現的是 virtual base class subobject, 其位置會因為每次衍生動作而有變化,只能被間接存取, compiler 會在子類別中安插一些指標,每個指標指向一個 virtual base class.這樣的做法有兩個缺點:

1. 每個物件必須針對其每個 virtual base class 背負一個額外指標(空間增加).
2. 由於虛擬繼承串鏈的加長,導致間接存取層次增加.(時間增加)

大部分編譯器到今天仍使用"經由拷貝動作取得所有的 nested virtual base class 指標,放到 derived class object 之中"來解決第二個問題.

第一個問題一般有兩個解法. Microsoft compiler 引入 virtual base class table, 每一個 class object 如果有一個或多個 virtual base class, 就會由 compiler 安插一個 pointer, 指向 virtual base class table. 第二個方法是在 virtual function table 中放置 virtual base class 的 offset.

指向 data members 的指標

可用以決定 vptr 放在 class 的 begin 或 end, 另一個用途可用來決定 class 中的 access sections.

usage:

	printf("&Point3d::x=%p\n",&Point3d::x);

如果 vptr 在物件尾巴,則 offset 為 0

如果 vptr 在物件起頭,則 offset 為 4

但為何在尾巴時,傳回值總是多 1? 意即 1 主要是用以區分"沒有指向任何 data member" 的指標和 "指向第一個 data member" 的指標.

注意,此種額外的間接性會降低"把所有處理都搬移到暫存器中執行"最佳能力.

• 簡介
• default constructor
• copy constructor
• NRV
• 使用 member initialization list.

簡介

編譯器可能會有隱含的動作,如對 overload operator 的誤判. 因為 compiler 會自動去尋找最符合其意義的來解釋你的意圖.

constructor

以下是各種 default constructor 的建構情形. 一般若 class 沒有宣告 constructor, 那麼 compiler 會在需要時為他建立一個簡單的 constructor, 有四種狀況:

1. class 沒有 constructor, 但成員之中有 member object, 而該 member object 有 default constructor 時, compiler 必定會為前者合成一個 default constructor.

假設

class Dopey {...};
class Sneezy {...};
class Bashful {...};
class Snow_White {
	public:
		Dopey dopey;
		Sneezy sneezy;
		Bashful bashful;
	private:
		int mumble;
};

Snow_White 沒有 default constructor, 那麼 compiler 會為他合成一個 default constructor, 依序喚起 Dopey, Sneezy, Bashful 的 default constructor. 若 Snow_White 定義了 constructor 如下:

Snow_White::Snow_White:sneezy(1024) {
mumble=2048;
}

則 compiler 會擴充為

Snow_White::Snow_White();sneezy(1024) {
dopey.Dopey::Dopey();
sneezy.Sneezy::Sneezy(1024);
bashful.Bashful::Bashful();
mumble=2048;
}

2. 若 class 繼承一個帶有 default constructor 的 class, 則 compiler 會為這個 class 合成一個 constructor, 這個 constructor 只呼叫 parent class 的 constructor.

又若有多個 constructor, 但卻沒有 default constructor 時, compiler 會擴張各 constructor, 以便去呼叫必要的 default constructor. 但卻不會去合成一個新的 default constructor.

3. 若 class 有 virtual function 的時候, compiler 會在 default constructor 中把 vtable 初始化,以便讓子類別能正確呼叫到 virtual function 所對應的 function.

4. virtual base class, 各 compiler 的實作方法不同,但共通點都是要使 virtual base class 在每個 derived class object 中的位置,能夠在 runtime 時準備妥當.例如:

class X { public: int i; };
class A: public virtual X { public: int j; };
class B: public virtual X { public: double d; };
class C:public virtual X {public: int k;};
//無法在編譯時決議(resolve)出 pa->X::i
void foo( const A* pa) { pa->i=1024; }
int
main() {
	foo(new A);
	foo(new C);
//...
}

所以, compiler 必須改變"執行存取動作"的程式碼,使得 X::i 能延遲到 runtime 時才決定下來.

以上四種情況都會使 compiler 必須為未宣告 constructor 的 class 合成 default constructor, 這些被 compiler 合成出來的東西, 在 C++ Standard 中稱為 implict nontrival default constructor.

除了這四種情況之外, compiler 不會合成任何 constructor.

另外在合成的 default constructor 中, 只有 base class object 和 member class object 會被初始化, 其他 nonstatic data member,如: int, int*, int array 等都不會.

新手誤解:

1.任何 class 若沒有 default constructor, 就會自動合成一個.

2. compiler合成的 default constructor 會明白設定"class內每個 data member 的預設值".

copy constructor

有三種情況會以一 object 內容作為另一 class object 的初值.

1. string bb; string aa=bb;
2. object 被當作參數交給函式時.
3. 函數傳回值是 object 時.

當沒有提供 copy constructor 時,會直接把 member 一個個地複製到要複製的 object 上, 如:

class string {
	char *str;
	int len;
};

則

string noun("book");
string verb=noun;

實際上是

verb.str=noun.str;
verb.len=noun.len;

此處的 copy constructor 不等於 copy assignment (operator=)!!

default constructor 和 copy constructor 在必要的時候才用 compiler 產生出來.

請注意 member 若有 pointer 時,那麼預設會把指標指過去,就會有潛在的指標問題!

此種情況應宣告 explicit copy constructor 來解決此問題.如:

class string {
public:
	string(const char *);
	string(const string&);
};

一般 copy 會有四種情況, class 不展現出 "bitwise copy semantics"(即上述狀況):

1. 1.class 內含一個 member object 而後者有 copy constructor 時.
2. 2.class衍生自一個 base class, 而 base class 有 copy constructor 時.
3. 3.class宣告一個或多個 virtual functions.
4. 4.當 class 衍生自一個繼承串鏈,其中有一個或多個 virtual base classes.

第三種情況需考慮到之前第一章所提到的 virtual table.

因此若父類別有 animate() 和 draw()這兩個 virtual function,而子類別增加 dance(), 則不能

childclass cc1;
parentclass parent1=cc1;

會造成 virtual table 被切掉,因為 parent1 的 virtual table 根本就沒有 dance.若 parent1宣告為參考或指標時,被 compiler 合成出來的 copy constructor 會把隱含的 vptr 指向 childclass 的 virtual table, 而非 bitwise copy.這個也叫做 upcasting.

第四種情況則請回想一下 virtual base classes, 因為只會有一個實體存在,因此,compiler 會特別審慎考量,不會 bitwise copy.

NRV最佳化,如下情況會被 compiler

x bar() {
	X xx;
	//....
	return xx;
}

轉為如下的情況

void bar(X& __result) {
	__result.X::X();
	//....
	return;
}

NRV

NRV -> Named Return Value 提供重要效率改善.

使用 member initialization list.

時機:

1. 當初始化一個 reference member
2. 當初始化一個 const member 時
3. 當喚起一個 base class 的 constructor, 而他擁有一個參數時.
4. 當喚起一個 member class 的 constructor, 而他擁有一個參數時.

Why:

一般這樣寫, compiler 會先產生一暫存物件, 再 assign 給 member object, 所以效率不彰.

class Word {
	String _name;
	int _cnt;
public:
	Word(){
		_name=0;
		_cnt=0;
	}
};

所以要用 Word::Word:_name(0) {_cnt=0;}; 效率較佳.

缺點及注意事項:

注意 initialization list 的初始順序. 若 member object 依賴性太高,最好不要放到 initialization list 中,而應移至 constructor 中.