blocks|key|4275596|text|是的，确实如此。特别是，你会发现调试/发布堆的问题是不同的，如果你的库使用了placement+new，或者任何定制的堆，你都会有问题。到目前为止，调试/发布问题是最常见的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4275597|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

yes indeedy. In particular you see problems with debug/release heaps being different, also if your library uses placement new, or any custom heap you'll have a problem. The Debug/Release issue is by far the most common though.

blocks|key|3427825|text|是的，你会的。一个简单的解决方案是在库中提供可以从主应用程序调用的Create和Delete函数。Create函数将执行new并返回一个指针，该指针稍后被传递到Delete函数中进行删除。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3427826|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes, you will. A simple solution is to provide Create and Delete functions in your library that can be called from the main application. The Create function will perform the new and return a pointer, which is later passed into the Delete function for deletion.

blocks|key|972513|text|那得看情况。如果您谈论的是静态库，那么您可能没有问题--代码将在与主程序相同的上下文中运行，并使用相同的C%2B%2B运行时库。这意味着new和delete将使用相同的堆。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|972514|如果你在谈论一个共享库(一个DLL)，那么你可能就不会好了。在DLL中运行的代码可能使用不同的C%2B%2B运行时库，这意味着堆的布局将不同。DLL可能正在使用完全不同的堆。|972515|在DLL分配的指针上调用delete+(在主程序中)(反之亦然)将导致(最好的)立即崩溃或(最坏的)内存损坏，这将需要一段时间才能找到。|972516|你有几个选择。第一种是使用“工厂方法”模式来创建和删除这些对象：|972517|Foo+*CreateFoo();
void+DeleteFoo(Foo+*p);|code-block|syntax|javascript|972518|这些不应该在头文件中实现。|972519|或者，您可以在对象上定义Destroy方法：|972520|class+Foo
{
++++~Foo();

public:
++++virtual+void+Destroy();
};|972521|...again，不要在头文件中实现这一点。你可以这样实现它：|972522|void+Foo::Destroy()
{
++++delete+this;
++++//+don't+do+anything+that+accesses+this+object+past+this+point.
}|972523|注意，Foo的析构函数是私有的，所以您必须调用Foo::Destroy。|972524|Microsoft+COM做了类似的事情，它定义了一个Release方法，当引用计数降到零时删除对象。|972525|entityMap^0|1S|3|1W|6|0|0|C|6|0|0|0|0|C|7|0|0|0|0|N|C|0|R|7|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1F|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|1G|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|1H|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|U|3|V|5|N|7|1L|8|@]|D|@]|E|$O|P]]|$1|W|3|X|5|6|7|1M|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|N|7|1N|8|@]|D|@]|E|$O|P]]|$1|10|3|11|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|12|3|13|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|14|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]]|15|$]]

It depends. If you're talking about a static library, then you'll probably be OK -- the code will run in the same context as the main program, using the same C++ runtime library. This means that <code>new</code> and <code>delete</code> will use the same heap.

If you're talking about a shared library (a DLL), then you probably won't be OK. The code running in the DLL might be using a different C++ runtime library, which means that the layout of the heap will be different. The DLL might be using a different heap altogether.

Calling <code>delete</code> (in the main program) on a pointer allocated by the DLL (or vice versa) will lead to (at best) an immediate crash or (at worst) memory corruption that'll take a while to track down.

You've got a couple of options. The first is to use the "factory method" pattern to create and delete these objects:

<pre><code>Foo *CreateFoo();
void DeleteFoo(Foo *p);
</code></pre>

These should not be implemented in the header file.

Alternatively, you can define a <code>Destroy</code> method on the object:

<pre><code>class Foo
{
 ~Foo();

public:
 virtual void Destroy();
};
</code></pre>

...again, don't implement this in the header file. You'd implement it thus:

<pre><code>void Foo::Destroy()
{
 delete this;
 // don't do anything that accesses this object past this point.
}
</code></pre>

Note that the destructor for Foo is private, so that you have to call <code>Foo::Destroy</code>.

Microsoft COM does something similar, where it defines a <code>Release</code> method that deletes the object when its reference count drops to zero.

blocks|key|4275713|text|你说的很对，那里有一个问题，但对于大多数情况，有一个比(到目前为止)其他答案更简单的解决方案。您可以继续使用new和delete+--您所需要做的就是为库中可能跨DLL边界使用的每个类重载new和delete。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4275714|就我个人而言，我只是定义了一个简单的类来提供所需的功能：|4275715|class+NewDelete
{
++++public:
++++++++void+*operator+new+(size_t+size);
++++++++void+operator+delete+(void+*memory);
++++++++void+*operator+new+(size_t+size,+void+*ptr);
++++++++void+operator+delete+(void+*memory,+void+*ptr);
};|code-block|syntax|javascript|4275716|只要这四个成员函数都定义在同一个DLL中，那么从这个类派生的任何类都自动是“DLL安全的”--+new和delete可以在它们上正常使用，而不用担心DLL的边界。|4275717|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You're quite right that there's a problem there, but for most cases there's an even simpler solution than the other answers (so far) have proposed. You can continue using new and delete freely -- all you need to do is overload new and delete for each class in your library that might be used across DLL boundaries.

Personally, I just defined a simple class to provide the needed functionality:

<pre><code>class NewDelete
{
 public:
 void *operator new (size_t size);
 void operator delete (void *memory);
 void *operator new (size_t size, void *ptr);
 void operator delete (void *memory, void *ptr);
};
</code></pre>

As long as those four member functions are all defined in the same DLL, then any class which derives from this class is automatically "DLL-safe" -- new and delete can be used normally on them without worrying about DLL boundaries.

blocks|key|972577|text|这是一个我只在Windows上看到的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|972578|Unixish系统不习惯于强制共享库链接到同一程序中同一库的不同版本，并且所有加载的符号都是全局可见的。这意味着，如果一个对象在代码的一部分被分配，而在另一部分被删除，那么两者都使用相同的系统库来完成。|972579|我不得不说，Windows使用其各种C运行时DLL造成的这个问题对C程序员来说是非常恼人和不自然的。看看C库；它有像strdup这样的函数，可以对字符串进行malloc，并期望程序员对其调用free()。但是在你自己的Windows库中做同样的事情，就等着它爆炸吧。您也必须等待，因为它不会在开发过程中发生，而是在您将编译后的DLL提供给其他一些可怜的sap之后才会发生。|972580|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It is a problem that I have only seen on Windows.

The Unixish systems do not make a habit of forcing shared libraries to link to different versions of the same library within the same program and all loaded symbols are visible globally. That means that if an object is allocated in one part of code and deleted in another, both are using the same system library to do it.

I have to say, this problem Windows creates with its various C runtime DLLs is really annoying and unnatural to a C programmer. Look at the C library; it has functions like strdup that malloc the string and expect the programmer to call free() on it. But do the same thing in your own library on Windows and just wait for the explosion. You'll have to wait, too, because it won't happen during development but only after you've given the compiled DLL to some other poor sap.

blocks|key|3427972|text|Old+New+Thing以前已经报道过这一点。他还列出了微软的主要解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3427973|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/oldnewthing/archive/2006/09/15/755966.aspx^0|0|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://blogs.msdn.com/oldnewthing/archive/2006/09/15/755966.aspx" rel="nofollow noreferrer">Old New Thing</a> has covered this before. He also gives a list of Microsoft's main solutions.

If I use the <code>new</code> keyword in my library (which is built differently than my main app), when I delete it in my main app with <code>delete</code>, is there a chance that I may get a crash/error?

C++ mix new/delete between libs?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如果我在我的库中使用new关键字(它的构建与我的主应用程序不同)，当我使用delete在我的主应用程序中删除它时，我是否有可能收到崩溃/错误？

问C++在库之间混合新建/删除？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++在库之间混合新建/删除？EN