blocks|key|4308778|text|模板参数可以是pointer+to+member，因此您可以通过这种方式扩充StartThread，并使Thread::Thread的指向成员的指针参数成为模板参数。您不能向构造函数模板提供显式的模板参数，因此您必须使用特殊的“tag”参数来传达它们：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4308779|template<class+C,class+T,T+C::*P>
DWORD+WINAPI+StartThread(PVOID+ptr)+{
++(static_cast<C*>(ptr)->*P)();
++return+1;
}

template<class+C,class+T,T+C::*P>
struct+Tag+{};

class+Thread+{
private+:
++HANDLE+native_handle+=+0;
++DWORD+id+=+0;
public+:
++template<class+C,class+T,T+C::*P>
++Thread(Tag<C,T,P>,C*);
++bool+run();
};

template<class+C,class+T,T+C::*P>
Thread::Thread(Tag<C,T,P>,C*+original)
{
++native_handle+=+CreateThread(0,+0,+StartThread<C,T,P>,original,
+++++++++++++++++++++++++++++++CREATE_SUSPENDED,+&id);
}

bool+Thread::run()+{
++DWORD+res+=+ResumeThread(native_handle);
++if+(res+==+(DWORD)-1)+return+false;
++return+true;
}


class+testt+{
public+:
++void+testf()+{
++++MessageBoxA(0,+"working",+"",+0);
++}
++void+doIt()+{
++++Thread+t(Tag<testt,void(),&testt::testf>(),this);
++++t.run();
++}
};

int+main()+{
++testt+tt;
++tt.doIt();
}|code-block|syntax|javascript|4308780|请注意，成员类型为T的void()函数类型；在模板参数类型为auto的C%2B%2B17中提供了更简单的语法。|4308781|或者，通过创建一个包含T*和T::*的结构并将指向它的指针作为PVOID传递给它，将其保留为普通参数。这种方式的诀窍在于，您需要使用类型擦除来正确地销毁该块，或者使用reinterpret_cast将指针临时存储在固定类型下(就像对StartThread所做的那样)。|4308782|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/language/template_parameters^0|12|B|1G|E|7|H|0|0|0|9|1|B|6|U|4|0|B|2|E|4|V|5|2B|G|38|B|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

A template parameter can be a <a href="http://en.cppreference.com/w/cpp/language/template_parameters" rel="nofollow noreferrer">pointer to member</a>, so you can augment <code>StartThread</code> that way and make <code>Thread::Thread</code>’s pointer-to-member parameter a template parameter. You can’t supply explicit template arguments to a constructor template, so you’ll have to use a special “tag” argument to convey them:

<pre><code>template&lt;class C,class T,T C::*P&gt;
DWORD WINAPI StartThread(PVOID ptr) {
 (static_cast&lt;C*&gt;(ptr)-&gt;*P)();
 return 1;
}

template&lt;class C,class T,T C::*P&gt;
struct Tag {};

class Thread {
private :
 HANDLE native_handle = 0;
 DWORD id = 0;
public :
 template&lt;class C,class T,T C::*P&gt;
 Thread(Tag&lt;C,T,P&gt;,C*);
 bool run();
};

template&lt;class C,class T,T C::*P&gt;
Thread::Thread(Tag&lt;C,T,P&gt;,C* original)
{
 native_handle = CreateThread(0, 0, StartThread&lt;C,T,P&gt;,original,
 CREATE_SUSPENDED, &amp;id);
}

bool Thread::run() {
 DWORD res = ResumeThread(native_handle);
 if (res == (DWORD)-1) return false;
 return true;
}


class testt {
public :
 void testf() {
 MessageBoxA(0, "working", "", 0);
 }
 void doIt() {
 Thread t(Tag&lt;testt,void(),&amp;testt::testf&gt;(),this);
 t.run();
 }
};

int main() {
 testt tt;
 tt.doIt();
}
</code></pre>

Note the <code>void()</code> function type as the member type <code>T</code>; simpler syntax is available in C++17 with <code>auto</code> in a template parameter’s type.

Or preserve it as a normal parameter by making a struct containing a <code>T*</code> and a <code>T::*</code> and passing a pointer to it as your <code>PVOID</code>. The trick this way is that you’ll need to use type erasure to destroy that block correctly, or else use <code>reinterpret_cast</code> to store the pointers temporarily under fixed types (as already done for <code>StartThread</code>).

blocks|key|4308953|text|如果不使用std::thread和std::function等C%2B%2B运行时，您的选择就会受到一些限制。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4308954|尝试更多像这样的东西：|4308955|template+<class+U>
class+Thread+{
private:
++++HANDLE+native_handle+=+0;
++++DWORD+id+=+0;
++++U+*object;
++++void+(U::*object_member)();

++++static+DWORD+WINAPI+ThreadProc(PVOID+ptr);

public:
++++Thread(void+U::*member,+U*+obj);

++++bool+start();
};

template<class+U>
DWORD+WINAPI+Thread::ThreadProc(PVOID+ptr)+{
++++Thread+*t+=+static_cast<Thread*>(ptr);
++++U+*obj+=+t->object;
++++void+(U::*member)()+=+t->object_member;
++++(obj->*member)();
++++return+1;
}

template<class+U>
Thread::Thread(void+U::*member,+U*+obj)+:
++++object_member(member),+object(obj)+{
++++native_handle+=+CreateThread(0,+0,+&ThreadProc,+this,+CREATE_SUSPENDED,+&id);
}

template+<class+U>
bool+Thread::start()+{
++++return+(ResumeThread(native_handle)+!=+(DWORD)-1);
}

class+testt+{
public:
++++void+testf()+{
++++++++MessageBoxA(0,+"working",+"",+0);
++++}

++++void+doIt()+{
++++++++Thread<testt>+t(&testt::testf,+this);
++++++++t.start();
++++}
};

int+main()+{
++++testt+tt;
++++tt.doIt();
}|code-block|syntax|javascript|4308956|否则，您可能不得不求助于更像这样的东西：|4308957|class+Thread+{
private:
++++HANDLE+native_handle+=+0;
++++DWORD+id+=+0;
++++void+(*func)(void*);
++++void+*param;

++++static+DWORD+WINAPI+ThreadProc(PVOID+ptr);

public:
++++Thread(void+(*f)(void*),+void*+p);
++++bool+start();
};

DWORD+WINAPI+Thread::ThreadProc(PVOID+ptr)+{
++++Thread+*t+=+static_cast<Thread*>(ptr);
++++void+(*func)(void*)+=+t->func;
++++(*func)(t->param);
++++return+1;
}

Thread::Thread(void+(*f)(void*),+void+*p)+:
++++func(f),+param(p)+{
++++native_handle+=+CreateThread(0,+0,+&ThreadProc,+this,+CREATE_SUSPENDED,+&id);
}

bool+Thread::start()+{
++++return+(ResumeThread(native_handle)+!=+(DWORD)-1);
}

class+testt+{
private:
++++static+void+proc(void+*p)+{
++++++++static_cast<testt*>(p)->testf();
++++}
public:
++++void+testf()+{
++++++++MessageBoxA(0,+"working",+"",+0);
++++}
++++void+doIt()+{
++++++++Thread+t(&testt::proc,+this);
++++++++t.start();
++++}
};

int+main()+{
++++testt+tt;
++++tt.doIt();
}|4308958|entityMap^0|5|B|H|D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

Without the use of the C++ runtime, like <code>std::thread</code> and <code>std::function</code>, your options are a bit limited.

Try something more like this:

<pre><code>template &lt;class U&gt;
class Thread {
private:
 HANDLE native_handle = 0;
 DWORD id = 0;
 U *object;
 void (U::*object_member)();

 static DWORD WINAPI ThreadProc(PVOID ptr);

public:
 Thread(void U::*member, U* obj);

 bool start();
};

template&lt;class U&gt;
DWORD WINAPI Thread&lt;U&gt;::ThreadProc(PVOID ptr) {
 Thread *t = static_cast&lt;Thread*&gt;(ptr);
 U *obj = t-&gt;object;
 void (U::*member)() = t-&gt;object_member;
 (obj-&gt;*member)();
 return 1;
}

template&lt;class U&gt;
Thread&lt;U&gt;::Thread(void U::*member, U* obj) :
 object_member(member), object(obj) {
 native_handle = CreateThread(0, 0, &amp;ThreadProc, this, CREATE_SUSPENDED, &amp;id);
}

template &lt;class U&gt;
bool Thread&lt;U&gt;::start() {
 return (ResumeThread(native_handle) != (DWORD)-1);
}

class testt {
public:
 void testf() {
 MessageBoxA(0, "working", "", 0);
 }

 void doIt() {
 Thread&lt;testt&gt; t(&amp;testt::testf, this);
 t.start();
 }
};

int main() {
 testt tt;
 tt.doIt();
}
</code></pre>

Otherwise, you may have to resort to something more like this:

<pre><code>class Thread {
private:
 HANDLE native_handle = 0;
 DWORD id = 0;
 void (*func)(void*);
 void *param;

 static DWORD WINAPI ThreadProc(PVOID ptr);

public:
 Thread(void (*f)(void*), void* p);
 bool start();
};

DWORD WINAPI Thread::ThreadProc(PVOID ptr) {
 Thread *t = static_cast&lt;Thread*&gt;(ptr);
 void (*func)(void*) = t-&gt;func;
 (*func)(t-&gt;param);
 return 1;
}

Thread::Thread(void (*f)(void*), void *p) :
 func(f), param(p) {
 native_handle = CreateThread(0, 0, &amp;ThreadProc, this, CREATE_SUSPENDED, &amp;id);
}

bool Thread::start() {
 return (ResumeThread(native_handle) != (DWORD)-1);
}

class testt {
private:
 static void proc(void *p) {
 static_cast&lt;testt*&gt;(p)-&gt;testf();
 }
public:
 void testf() {
 MessageBoxA(0, "working", "", 0);
 }
 void doIt() {
 Thread t(&amp;testt::proc, this);
 t.start();
 }
};

int main() {
 testt tt;
 tt.doIt();
}
</code></pre>

blocks|key|4309018|text|最后，我用winapi替代std::thread，它的工作原理相同，而且可能更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4309019|class+letTest+{
private+:
++void+pri(int+u,float+g,+char+l)+{
++++++MessageBoxA(0,+0,+0,+0);
++}

public+:
++int+doIt(int+o)+{
++++++auto+t+=+thread(&letTest::pri,+this,5,4.2,'k');+//+works+well+with+any+number+and+type+of+parameters
++++++t.join();
++++++return+5;
++}
};|code-block|syntax|javascript|4309020|也可以使用常用函数|4309021|void+ltest(int+i)+{
+++MessageBoxA(0,+to_string(i).c_str(),+0,+0);
}
int+main()+{
+++auto+t+=+thread(ltest,+4);
+++t.join();
}|4309022|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I ended with a winapi alternative for std::thread and works the same and is probably better

<pre><code>class letTest {
private :
 void pri(int u,float g, char l) {
 MessageBoxA(0, 0, 0, 0);
 }

public :
 int doIt(int o) {
 auto t = thread(&amp;letTest::pri, this,5,4.2,'k'); // works well with any number and type of parameters
 t.join();
 return 5;
 }
};
</code></pre>

also with usual functions 

<pre><code>void ltest(int i) {
 MessageBoxA(0, to_string(i).c_str(), 0, 0);
}
int main() {
 auto t = thread(ltest, 4);
 t.join();
}
</code></pre>

I'm trying to create a thread with a non-static class member, like this:

<pre><code>template &lt;class clName&gt;
 DWORD WINAPI StartThread(PVOID ptr) {
 ((clName*)(ptr))-&gt;testf(); // this is static member name I want to be able use different names with the same function
 return 1;
 }

class Thread {
 private :
 HANDLE native_handle = 0;
 DWORD id = 0;
public :
 template &lt;class T,class U&gt;
 Thread(T U::*member,U* original); // I want to use different members with the same function
 bool run();
}

template&lt;class T,class U&gt;
Thread::Thread(T U::*member, U* original)
{
 native_handle = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)StartThread&lt;U&gt;,original, CREATE_SUSPENDED, &amp;id);
}

bool Thread::run() {
 DWORD res = ResumeThread(native_handle);
 if (res == (DWORD)-1) return false;
 return true;
}


class testt {
public :
 void testf() {
 MessageBoxA(0, "working", "", 0);
 }
 void doIt() {
 Thread t(&amp;testt::testf,this);
 t.run();
 }
};

int main() {
 testt tt;
 tt.doIt();
}
</code></pre>

As you see, I can only run a particular member, so this method isn't portable and can't be used for any class or member.

I know I can use <code>std::thread</code> easily, but I'm working on a project that I shouldn't use any C++ runtime in, so I am creating wrappers for <code>new</code>/<code>delete</code>, threads, file I/O, etc. Otherwise, I always use <code>std::thread</code> and it's fantastic. In this project, I have to use Win32 API only.

c++ CreateThread non static member without particular member name

我正在尝试创建一个包含非静态类成员的线程，如下所示：template <class clName> DWORD WINAPI StartThread(PVOID ptr) { ((clName*)(ptr))->testf(); // this is static member name I want to be ...

问没有特定成员名称的c++ CreateThread非静态成员
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问没有特定成员名称的c++ CreateThread非静态成员EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问没有特定成员名称的c++ CreateThread非静态成员
EN