从CLR GUI实现非托管班级时，stackoverflow异常提出

Question

我正在编写C /CLR GUI，以围绕一些未托管的C 代码，我正在为测试目的编写。

我使用一个名为HolderOfUnmanagedStuff的代理类来实现我在CLR GUI中需要的几个未托管的对象。

#pragma once
#include "foo.h"
namespace fooCore
{
    public class HolderOfUnmanagedStuff
    {
    public:
        HolderOfUnmanagedStuff()
        {
            foos = std::vector<fooCore::foo>();
        }
        ~HolderOfUnmanagedStuff() { }
    public:
        std::vector<fooCore::foo> foos;
        void addFoo(std::string & fileName)
        {
            whatever code on the first line    // <-- System.StackOverflowException
            foo myfoo(FileName);  // <--- when I comment those 2 lines no exception
            foos.push_back(foo);  //      but exception when I comment only this one
        }
        otherUnmanagedMembers ...
    };
}

我的foo类使用一个从文件中读取对象的构造函数：

#pragma once
namespace fooCore
{    
    class foo
    {
    public:
        foo();
        foo(std::string & fileName);
        ~foo();
         fooMembers...
    };
}

每当我尝试实现FOO类时，我都会在函数的第一行中获得堆栈溢出异常。

呼叫堆栈仅显示逻辑呼叫层次结构：一个按钮事件，然后呼叫addfoo函数，这就是全部

我已经尝试了多个解决方案，重写了每个构造函数，检查了未管理/托管冲突，指针，地址，参考。

我学到了很多东西(显然，因为我已经编写了15年来没有掌管的代码(，但是我找不到问题。有什么想法吗？

编辑

我尝试了几件事：

1. 向我的持有人添加了一个foo成员：ok

2. 试图在构造函数中定义该成员：构造函数中的异常

3. 将FOO成员推入AddFoo函数中的Foo向量：OK

4. 在addfoo中定义foo成员：异常

以下代码显示了我进行的4个测试：

public class HolderOfUnmanagedStuff
{
    public:
        HolderOfUnmanagedStuff()
        {
            ...
            memberFoo = foo(); // TEST 2 : SOF exception on the first line of the constructor
        }
        ~HolderOfUnmanagedStuff() { }
    public:
        foo memberFoo;    // TEST 1 : No exception with that line 
        std::vector<fooCore::foo> foos;
        void addFoo(std::string & fileName)
        {
            ...               
            foos.push_back(memberFoo);  // TEST 3 No exception with that line
            memberFoo = foo();  // TEST 4 SOF on the first line of the function
        }
        otherUnmanagedMembers ...
    };

Answer 1

例外是由于我的foo类太大的事实。

我修改了我的代码，以便默认构造函数在数据段(在堆上(声明每个foo对象。没有更多的堆栈溢出，数据结构更合乎逻辑。