string

有一些簡單問題復雜化
跨平臺問題平臺綁定的意思
而且還有多線程問題

@天堂的隔壁
多謝賜教。 是搞的挺復雜的。但可以把這套復雜的東西放到頭文件里，用戶不用關心。 用戶只要調用slaunchX就可以了， 不過這種簡單的線程好像不大實用。

@djx_zh

int 囧(int a, string b, void* c)
{
throw "囧";
}

class 囧Getter
{
public:
void Get囧(int result);
}

--------------------
囧Getter 囧getter;
RunAsync(囧, Func<void(int)>(&囧getter, &囧Getter::Get囧), 1, "vczh", 0);
RunAsync(囧, 1, "vczh", 0);
--------------------
這樣就好用了，因為C++編譯器會替你檢查錯誤。譬如說穿進去的囧函數(shù)第二個參數(shù)是float，編譯器就會抱怨你參數(shù)"vczh"不對
--------------------
一般來說你只需要支持0到10個參數(shù)，還有返回void或者有返回值的函數(shù)，特化22個就行了。

@陳梓瀚(vczh)
對，模板比宏好用。

呵呵,用到了匯編,看的頭大,我模板做了一個如何


template< typename R, typename T>
R _cast(T t)
{
return t;
}

template< typename R>
R _cast(std::tr1::shared_ptr< typename std::tr1::remove_pointer<R>::type > t)
{
return t.get();
}

template<typename F>
class thread_closure_0
{
public:

thread_closure_0(const F& f, const tchar* nm = 0)
: _function(f)
, _name((0 == nm) ? _T("") : nm)
{
}

static void start_routine(void* c)
{
thread_closure_0 *self = static_cast<thread_closure_0*>(c);
try
{
self->_function();
}
catch (...)
{
delete self;
throw;
}

delete self;
}

const tstring& name() const
{
return _name;
}
private:
F _function;
tstring _name;
};

template<typename F, typename P>
class thread_closure_1
{
public:

thread_closure_1(const F& f, const P& x, const tchar* nm = 0)
: _function(f)
, _name((0 == nm) ? _T("") : nm)
, arg1(x)
{
}

static void start_routine(void* c)
{
thread_closure_1 *self = static_cast<thread_closure_1*>(c);
try
{
self->_function(self->arg1);
}
catch (...)
{
delete self;
throw;
}
delete self;
}

const tstring& name() const
{
return _name;
}
private:
F _function;
tstring _name;
P arg1;
};

template<typename F>
inline void create_thread(const F& f, const tchar* nm = null_ptr)
{
typedef thread_closure_0<F> closure_type;

// _beginthread創(chuàng)建線程時，其返回值可能是一個無效句柄(太快而被關閉了)，千萬不要對它作操
// 作，如 WaitForSingleObject 等,具體見幫助
uintptr_t handle = ::_beginthread(closure_type::start_routine, 0, new closure_type(f, nm));
if (-1L != handle)
return;

if (null_ptr != nm)
ThrowException1(RuntimeException, _T("啟動線程[") + tstring(nm) + _T("]失敗"));
else
ThrowException1(RuntimeException, _T("啟動線程失敗"));
}

template<typename F, typename P>
inline void create_thread(const F& f, const P& x, const tchar* nm = null_ptr)
{
typedef thread_closure_1<F, P> closure_type;

// _beginthread創(chuàng)建線程時，其返回值可能是一個無效句柄(太快而被關閉了)，千萬不要對它作操
// 作，如 WaitForSingleObject 等,具體見幫助
uintptr_t handle = ::_beginthread(closure_type::start_routine, 0, new closure_type(f, x, nm));
if (-1L != handle)
return;

if (null_ptr != nm)
ThrowException1(RuntimeException, _T("啟動線程[") + tstring(nm) + _T("]失敗"));
else
ThrowException1(RuntimeException, _T("啟動線程失敗"));
}

@梅發(fā)坤
Cool, 這樣就清晰多了，還容易調試。