Thinking more...

#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 );

#include <stdio.h>

int say_hello( void )
{
    printf("Hello world!!\n");
    return 0;
}

int main( int argc, char* argv[] )
{
    int flag=0;

    printf("flag=0\n");
    flag && say_hello(); // say_hello() won't be invoked
    flag || say_hello(); // say_hello() will be invoked

    printf("flag=1\n");
    flag=1;
    flag && say_hello(); // say_hello() will be invoked
    flag || say_hello(); // say_hello() won't be invoked

    return 0;
}

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 );
// 省略兩萬行...
}

static gboolean expose_event( GtkWidget* widget, GdkEventExpose* event, gpointer data )
{
	GError* error=NULL;
	int width=widget->allocation.width, height=widget->allocation.height;

	GdkPixbuf* buf=gdk_pixbuf_new_from_file_at_scale( "your_photo.jpg", &error );
	if( buf==NULL )
		g_print("load fail.\n" );
	else
	{
		bufWidth = gdk_pixbuf_get_width( buf );
		bufHeight = gdk_pixbuf_get_height( buf );
		gdk_draw_pixbuf( widget->window, NULL, buf, 0, 0, 0, 0, 
				(width>bufWidth?bufWidth:width), (height>bufHeight?bufHeight:height), 
				GDK_RGB_DITHER_NORMAL, 0, 0 );
		g_object_unref( buf );
	}
}

int main( int argc, char* argv[])
{
	GtkWidget* drawing_area=NULL;

	// 省略一萬行
	g_signal_connect( G_OBJECT(drawing_area), "expose_event", G_CALLBACK( expose_event ), NULL );

	// 再省略兩萬行...	
}

/**
 *       Filename:  test_new.cpp
 *    Description:  Test new(storage) Person();
 */
#include <cstdlib>
#include <string>
#include <iostream>

class Person {
	public:
		Person() {}
		~Person() {}

		std::string getName() { return _name; };
		void setName( std::string name ) { _name=name; }

		std::string toString() { return _name; }
	private:
		std::string _name;
};

int main( int argc, char* argv[] ) {
	char* storage = (char*)malloc( 1024 ); // allocate 1K

	Person* person = new(storage) Person();
	person->setName( "anonymous" );
	std::cout << person->toString() << std::endl;

	// if just storage, person will be replaced by intArray. (2)
	// int* intArray = new(storage) int[10];
	int* intArray = new(storage+sizeof(person)) int[10];
	int i=0;

	// assign value.
	for( i=0; i<10; i++ )
		intArray[i] = i;

	// show the values
	for( i=0; i<10; i++ )
		printf( "%d ", intArray[i]);
	printf("\n");

	// dump storage
	char* iter=storage;
	printf("=== begin dump ===\n");
	i=0;
	while( i!=512 ) {
		printf( "%02x ", (unsigned char)*iter );
		iter++;
		i++;
		if( !(i%16) )
			printf( "\n" );
	}
	printf("=== end dump ===\n");

	printf( "person address = %08x intArray address = %08x\n",
			(unsigned int)person, (unsigned int)intArray );

	// cannot delete, it cause segmentation fault. (1)
	//delete person;
	//delete[] intArray;

	// but we can use free.
	free( storage );
}

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\ 下