原生C++；到托管C++；到C# 我正在从C语言中移植大量的.h和.LB文件到托管C++，最终作为引用C++中的.dll，

拜托，我知道把整个东西移植到.NET会容易得多，但如果可以的话，我会的。这是第三方，我只有.lib（无导出）和.h文件可供使用

在我使用虚拟函数之前，一切都很顺利，现在我遇到了一些代理问题

我遇到的错误包括：

错误C3756:“ThreadFunc”：委托定义与现有符号冲突
错误C2079:“MyWrapTest:：MyThreadWrap:：m_threadAttr”使用未定义的类“MyWrapTest:：mythreadattrrap” 错误C2664:“MyWrapTest:：AutoPtr:：AutoPtr（T*）”：无法将参数1从“MyWrapTest:：MyThreadAttrWrap”转换为“MyThread*”

为了清楚起见，我将包括本机代码和我现在正在研究的内容。首先，本机代码：

#ifndef MYTHREAD_HPP
#define MYTHREAD_HPP

#ifdef WIN32
#include <winsock2.h>
#include <windows.h>
#define STDCALL unsigned __stdcall
typedef unsigned (__stdcall *ThreadFunc)(void*);
#else
#define STDCALL void*
typedef void* (*ThreadFunc)(void*);
typedef unsigned int HANDLE ;
#endif
#include "generaltypes.hpp"

class MyThreadAttr;

class MyThread
{
public:
    MyThread(void);
    MyThread(MyThreadAttr * tta);
    virtual ~MyThread() {};
    virtual HANDLE start(ThreadFunc,void *, unsigned *);
    virtual int stop();
    static void wait(HANDLE);
#ifdef WIN32
    static void wait(HANDLE, int);// msec timeout required since 'cancelThread' is no-op  
#endif                            
    static void sleep(unsigned int);
    static int32 cancelThread(HANDLE hThread);  // no-op on Windows (returns -1)!
#ifndef WIN32
    static void setCancelStates(void);
    static void endProcess(); 
#endif

protected:
  MyThreadAttr * m_threadAttr;
  void setThreadAttr(MyThreadAttr * tta);
};

#endif

\ifndef MYTHREAD\u水电站
#定义MYTHREAD_水电站
#ifdef WIN32
#包括
#包括
#定义STDCALL unsigned\uu STDCALL
typedef无符号（u stdcall*ThreadFunc）（void*）；
#否则
#定义STDCALL void*
typedef void*（*ThreadFunc）（void*）；
typedef无符号整数句柄；
#恩迪夫
#包括“generaltypes.hpp”
类MyThreadAttr；
类神话阅读
{
公众：
神话阅读（无效）；
MyThread（MyThreadAttr*tta）；
虚拟~MyThread（）{}；
虚拟句柄开始（ThreadFunc、void*、unsigned*）；
虚拟int-stop（）；
静态无效等待（句柄）；
#ifdef WIN32
静态无效等待（句柄，int）；//需要毫秒超时，因为“cancelThread”没有操作
#恩迪夫
静态无效睡眠（无符号整数）；
静态int32 cancelThread（HANDLE hThread）；//在Windows上没有操作（返回-1）！
#ifndef WIN32
静态无效状态（无效）；
静态void endProcess（）；
#恩迪夫
受保护的：
MyThreadAttr*m_threadAttr；
void setThreadAttr（MyThreadAttr*tta）；
};
#恩迪夫

还有我正在开发的新东西：

#pragma once

#ifdef WIN32
#include <winsock2.h>
#include <windows.h>
#define STDCALL unsigned __stdcall
//typedef unsigned (__stdcall ThreadFunc)(Object^);
#else
#define STDCALL Object^
typedef unsigned int HANDLE;
#endif
#include "gentypes.hpp"
#include "AutoPtr.h"
#include "MyThread.hpp"

using namespace System;
using namespace System::Runtime::InteropServices;

namespace MyWrapTest
{

public delegate Object^ ThreadFunc(Object^ o);

ref class MyThreadAttrWrap;
//#include "MyThreadAttrWrap.h"

public ref class MyThreadWrap
{
public:
    MyThreadWrap(void)
    {
        AutoPtr<MyThread> m_NativeMyThread(new MyThread);
    };
    MyThreadWrap(MyThreadAttrWrap tta)
    {
        AutoPtr<MyThread> m_NativeMyThread(tta);
    };
    /*virtual ~MyThreadWrap(){};
    virtual HANDLE start(ThreadFunc,System::Object^, unsigned ^);
    virtual int stop();*/
    static void wait(HANDLE h)
    {
        m_NativeMyThread->wait(h);
    };
#ifdef WIN32
    static void wait(HANDLE h, int i) // msec timeout required since 'cancelThread' is no-op  
    {
        m_NativeMyThread->wait(h, i);
    };
#endif                            
    static void sleep(unsigned int i)
    {
        m_NativeMyThread->sleep(i);
    };
    static int32 cancelThread(HANDLE hThread);  // no-op on Windows (returns -1)!
#ifndef WIN32
    static void setCancelStates(void);
    static void endProcess(); 
#endif

protected:
  MyThreadAttrWrap m_threadAttr;
  void setThreadAttr(MyThreadAttrWrap tta);


private:
    AutoPtr<MyThread> m_NativeMyThread;
};
}

#pragma一次
#ifdef WIN32
#包括
#包括
#定义STDCALL unsigned\uu STDCALL
//typedef unsigned（u stdcall ThreadFunc）（对象^）；
#否则
#定义STDCALL对象^
typedef无符号整数句柄；
#恩迪夫
#包括“gentypes.hpp”
#包括“AutoPtr.h”
#包括“MyThread.hpp”
使用名称空间系统；
使用名称空间System:：Runtime:：InteropServices；
名称空间MyWrapTest
{
公共委托对象^ThreadFunc（对象^o）；
ref类MyThreadAttrWrap；
//#包括“MyThreadAttrWrap.h”
公共引用类MyThreadWrap
{
公众：
MyThreadWrap（无效）
{
AutoPtr m_NativeMyThread（新MyThread）；
};
MyThreadWrap（MyThreadWrap）
{
AutoPtr m_NativeMyThread（tta）；
};
/*虚拟~MyThreadWrap（）{}；
虚拟句柄启动（ThreadFunc，System:：Object^，unsigned^）；
虚拟int-stop（）*/
静态无效等待（句柄h）
{
m_NativeMyThread->wait（h）；
};
#ifdef WIN32
静态void wait（HANDLE h，int i）//需要毫秒超时，因为“cancelThread”没有操作
{
m_NativeMyThread->wait（h，i）；
};
#恩迪夫
静态无效睡眠（无符号整数i）
{
m_NativeMyThread->sleep（i）；
};
静态int32 cancelThread（HANDLE hThread）；//在Windows上没有操作（返回-1）！
#ifndef WIN32
静态无效状态（无效）；
静态void endProcess（）；
#恩迪夫
受保护的：
MyThreadAttrWrap m_threadAttr；
void setThreadAttr（mythreadattr）；
私人：
AutoPtr m_NativeMyThread；
};
}

为什么要在构造函数中再次定义m_NativeMyThread——这使其成为局部变量，您可能需要这样：

MyThreadWrap()
    : m_NativeMyThread(new MyThread)
{
};

或

MyThreadWrap（）
{
m_NativeMyThread=AutoPtr（新的MyThread）；
};

我通常不使用.Net，所以我不确定AutoPtr的语义，但您希望更改您的成员对象，而不是创建局部阴影

至于错误，在这里创建类型为AutoPtr的新本地对象，并向其传递一个类型为MyThreadAttrWrap的参数。 MyThreadWrap（MyThreadWrap） { AutoPtr m_NativeMyThread（tta）； }; （我把它当作C++来读，如果.NET混淆了，请指正我）

您需要的是使用新的MyThread对象初始化m_NativeMyThread，该对象是使用从传递给构造函数的MyThreadAttrWrap中提取的非托管MyThreadAttr*对象构造的

MyThreadWrap(MyThreadAttrWrap tta)
{
    m_NativeMyThread = AutoPtr<MyThread>(new MyThread(tta.GetNativeAttr()));
};

MyThreadWrap（mythreadattrrap）
{
m_NativeMyThread=AutoPtr（新的MyThread（tta.GetNativeAttr（））；
};

顺便说一句，对所有权要非常小心。从您发布的代码来看，不清楚MyThread是否拥有MyThreadAttr，或者它是否由外部拥有。AutoPtr拥有它的封闭指针（如果命名正确的话）。

Eugene

谢谢你的意见。在漫长的一天之后，我喜欢疲惫的眼睛。你说得对，AutoPtr声明了错误的类型

至于本机线程对象的“卷影副本”，我确实遵循了Microsoft推荐的一个有良好文档记录的实践，以确保本机对象管理在.NET中正确完成

学员问题也与眼睛疲劳有关。我需要更改委托名称，以允许现有（本机）函数与新委托存在于同一空间中

---

我对转发声明仍有一些问题，但我相信我很快就能解决。

请突出显示所有代码并点击菜单顶部的0101按钮。

MyThreadWrap(MyThreadAttrWrap tta)
{
    m_NativeMyThread = AutoPtr<MyThread>(new MyThread(tta.GetNativeAttr()));
};