在.NET中使用C/C++LI实用程序：

我一直在开发一些DLL实用程序项目,以避免在其他项目中重复代码,以及我还没有尝试过的功能,算法和测试.其中一个项目是C/C++LI,我还在学习这种语言,所以这个问题可能听起来很愚蠢.由于我在C/C++LI,F#和C#中有Library Projects,我使用C#控制台应用程序来测试它们.它不能与C/C++LI项目一起使用,因此我创建了一个C/C++LI控制台测试项目.它从未起作用,当我更改原始DLL C的名称时,引用未更新.当我(最终)发现问题时,我更改了.vcxproj文件,使得using指令成为可能,就像一个方法一样,但不是模板类Apont< typename T>,这是某种内部指针,但是与.NET类型System :: IntPtr不同,使用类型T *而不是void *的值.

我还发现(从这个网站的帖子中)我必须在项目中使用我想要在外面使用的东西,否则那些东西想要在元数据中发出.所以我在静态实用程序中有一个无用的静态方法用于此目的：

static void Funcionalidades()
{
    int i = 10;

    Apont<int> a2 = Apont<int>(i);            // stack
    Apont<int> ^a3 = gcnew Apont<int>(i);     // heap CLR

}

尽管如此,它不起作用.这是我在C/C++LI测试项目中的主要方法：

int main(array<System::String ^> ^args)
{
    int y(10);
    Apont<int> a = Apont<int>(y);

    Console::ReadKey();
    return 0;
}

以下是错误(我知道它可以用intellisense错误编译,但无论如何我都会显示它们)：

error C2065: 'Apont' : undeclared identifier
error C2062: type 'int' unexpected
IntelliSense: identifier "Apont" is undefined
IntelliSense: type name is not allowed
IntelliSense: expected an expression

为什么这些错误在这里？我怎样才能纠正它们？

我很感激任何答复或回复.

编辑(澄清)：

>这些错误不会出现在Funcionalidades方法中,即在DLL项目中,而是在主方法上,即在DLL之外的测试项目中.
>我正在写头文件中的所有内容;我的意思是并非每个头文件都有一个相应的.cpp文件,尽管所有头文件都包含在至少一个.cpp文件中.
>关于Apont的更多信息：

> Apont是一个模板(因为T *在内部使用,并且“不允许在通用类型的参数上进行间接”).
> Apont有一个拷贝构造函数,所以Apont< int> a = Apont< int>(someInt)应该有效;
> Apont< int> a(someInt)不起作用;
> Apont是某种内部指针;而且我没有发布整个代码,因为它不相关,我必须翻译varibles的名字,它可能有我可以轻易修复的错误,但这只会分散你的注意力.

NTH EDIT(其中’n’是我不知道的数字)：

Apont的代码你一直在抱怨这么久：

template<typename T> public ref class Apont sealed : public IDisposable
    {
        bool eliminado;
        T *pointer;

        /*void Dispose(bool tudo)
        {
            if (!eliminado)
            {
                if (tudo)
                {
                    ~Apont();
                }
                else
                {
                    !Apont();
                }
            }
        }*/
        !Apont() // finalizador: limpa os recursos "unmanaged"
        {
            delete pointer;
            pointer = nullptr;
            eliminado = true;
        }

    public:
        Apont(T &valor)
        {
            pointer = &valor;
            eliminado = false;
            ErroSeNulo = false;
            ErroSeEliminado = true;
        }
        Apont(T &valor,bool erroSeEliminado,bool erroSeNulo)
        {
            pointer = &valor;
            eliminado = false;
            ErroSeEliminado = erroSeEliminado;
            ErroSeNulo = erroSeNulo;
        }
        Apont(Apont<T> %outroApont)
        {
            this->pointer = &outroApont
        }

        property bool ErroSeEliminado;
        property bool ErroSeNulo;
        property T Valor
        {
            T get()
            {
                if (pointer != nullptr)             
                    return *pointer;
                else if (eliminado && ErroSeEliminado)
                    throw gcnew ObjectDisposedException("O objeto já foi pelo menos parcialmente eliminadao.");
                else if (ErroSeNulo)
                    throw gcnew NullReferenceException();
                else
                    return 0;
            }
        }

        /*
        Apont operator ~(/*T valor* /)
        {
            // este operador tem de ser declarado fora desta classe 
        }*/
        T operator !(/*Apont apont*/)
        {
            return Valor;
        }
        void operator =(Apont<T> outroApont)
        {
            pointer = outroApont;
            ErroSeEliminado = outroApont.ErroSeEliminado;
            ErroSeNulo = outroApont.ErroSeNulo;             
        }
        template<typename U> void operator =(Apont<U> outroApont)
        {
            pointer = safe_cast<T>(outroApont.pointer);
            ErroSeEliminado = safe_cast<T>(outroApont.ErroSeEliminado);
            ErroSeNulo = safe_cast<T>(outroApont.ErroSeNulo);
        }
        /*
        void operator =(T *&outroPointer)
        {
            pointer = outroPointer;
        }
        template<typename U> void operator =(U *&outroPointer)
        {
            pointer = safe_cast<T>(outroPointer);
        }*/
        void operator =(T *outroPointer)
        {
            pointer = outroPointer;
        }
        template<typename U> void operator =(U *outroPointer)
        {
            pointer = safe_cast<T>(outroPointer);
        }


        ~Apont() // destruidor: limpa todos os recursos
        {               
            this->!Apont();
        }

        // Error C2605: 'Dispose': this method is reserved within a managed class
        // O código será gerado automaticamente a partir do finalizador e do destrutor
    };

    template<typename T> Apont<T> operator ~(T &valor)
    {
        return gcnew Apont<T>(valor);
    }