在C++中重载全局运算符new/delete
在C++中，全局运算符new/delete是用于动态内存分配和释放的。重载这两个运算符可以让您自定义内存管理的行为，以满足特定的需求。
在C++中，重载全局运算符new/delete的方法如下：
void* operator new(std::size_t size) {
// 自定义内存分配逻辑
return malloc(size);
}
void operator delete(void* ptr) noexcept {
// 自定义内存释放逻辑
free(ptr);
}需要注意的是，重载全局运算符new/delete时，需要保证重载后的行为与默认行为一致，以确保程序的正确性和稳定性。
在使用腾讯云的云服务器时，可以使用腾讯云提供的虚拟机或容器服务，以满足不同的应用场景和需求。腾讯云提供的云服务器可以满足各种规模的应用需求，并且提供了丰富的API和SDK，方便用户进行自定义开发。同时，腾讯云还提供了各种工具和服务，以帮助用户更好地管理和维护他们的云服务器。
推荐的腾讯云相关产品和产品介绍链接地址：
相关·内容
在将项目从Visual Studio 2010迁移到2017年的过程中，我遇到了一个问题。其中一个项目具有全局静态重载的new/delete运算符，在使用VS2017编译时，它会抛出一个错误，即new/delete运算符不能声明为静态的(它用于在VS2010上编译)。但是静态确保特定于翻译单元的这些过载的新/删除的范围。当不允许更多的静态new/delete操作符时，如何实现这一点。请帮我提一下建议。
浏览 19提问于2020-05-06得票数 1
3回答
我正在编写一个使用QT库的C++应用程序。我想在我的应用程序和QT中检测内存泄漏。因此，我已经使用这个引用在我的main.cpp中重载了new和delete操作符，但是QT没有使用重载操作符。显然，这似乎是一个名称空间问题。如何解决这个问题。
int numAllocUnits = 0;
ofstream myLogFile("/root/memLeak.log");
class MemoryLeak_Manav
{
public:
MemoryLeak_Manav() {
if (!myLogFile.is_open()) {
浏览 2提问于2011-11-30得票数 0
回答已采纳
2回答
我有一个使用C++项目的.net项目，它占用了大量内存。
我想知道是否有快速和简单的方法来计算由delete操作符释放的新字节和流出字节分配的流入字节。添加一些日志记录之类的。
两个运算符的源代码都是由Visual Studio提供的，所以我可以破解它。
问题是我可以看到巨大的VM消耗，我想调查原因。我尝试了几个内存分析器，但它们都不能处理.NET应用程序中的非托管C++分配
浏览 0提问于2011-08-04得票数 2
回答已采纳
new delete
或
::new ::delete
我想知道这个::的用途，因为如果我删除它们的话，它看起来正常工作。
这些都是在自动指针教程中编写的代码。
#include <cstddef>
size_t* alloc_counter(){
return ::new size_t;
}
void dealloc_counter(size_t* ptr){
::delete ptr;
}
浏览 1提问于2015-05-02得票数 10
回答已采纳
我在youtube上看了一个关于数据结构和如何制作我们自己的数据结构的系列节目。但是老师用::operator new()代替了::operator new()，用::operator delete()代替了delete[]，有什么区别吗？因为这是我第一次在::operator上看到c++
浏览 7提问于2020-08-22得票数 3
回答已采纳
C++参考页面列出了的8个类特定的重载。其中四个是为2017年版的C++添加的。
类特定分配函数
void* T::operator new ( std::size_t count );
void* T::operator new[]( std::size_t count );
void* T::operator new ( std::size_t count, std::align_val_t al ); // (since C++17)
void* T::operator new[]( std::size_t count, std::align_val_t al ); // (s
浏览 4提问于2017-08-06得票数 11
回答已采纳
1回答
将一个指针逐个复制到C++中的另一个元素，并获取"Error in `./hsc.exe'：double free or corruption (!prev)：0x0000000000aadcc0 * Aborted (core dumped)“。
我试着调试它，但我被“临时棒；”这行卡住了，因为我不能删除棒，因为我也在删除与"delete[]“相关的信息。
以下是代码的以下部分。
int * rods; // Defining rods and temp
int * temp;
int N_r =5;
rods = new int[N_r];
temp = new
浏览 2提问于2016-02-12得票数 0
这是操作符new和operator delete重载的代码示例。
我的预期产出是：
Overloaded new
The value is :10
Overloaded delete
但我得到了：
Overloaded new
The value is :10
#include <iostream>
#include <stdlib.h>
using namespace std;
void *operator new(size_t n)
{
cout<<"Overloaded new" <<endl;
v
浏览 3提问于2022-08-21得票数 -2
2回答
放置新的和删除
、、、
删除这里分配的所有内存的正确方法是什么？
const char* charString = "Hello, World";
void *mem = ::operator new(sizeof(Buffer) + strlen(charString) + 1);
Buffer* buf = new(mem) Buffer(strlen(charString));
delete (char*)buf;
或
const char* charString = "Hello, World";
void *mem = ::operator new(
浏览 0提问于2011-07-22得票数 64
回答已采纳
我有这个重载操作符new和delete的示例代码
#include <iostream>
#include <cstddef>
#include <new>
#ifdef USE_ZMALLOC
extern "C" {
#include "zmalloc.h"
}
#define m_malloc zmalloc
#define m_free zfree
#else
#ifdef USE_JEMALLOC
#include <jemalloc/jemalloc.h>
#define m_malloc je_ma
浏览 3提问于2017-05-16得票数 4
如何确定C++ new运算符分配的内存大小。？
在C中，malloc的语法是：
void *malloc(size_t size);
这里我们知道我们分配的是什么大小。
但是在C++中，当我们像下面这样做内存分配时，我们如何确定分配的大小。我想知道new是如何决定需要分配的大小的。
foo *pFoo = new foo();
浏览 0提问于2014-04-14得票数 5
因此，我正在尝试创建一个基类，它对这类基类具有默认的去分配函数。根据我删除派生对象的方式，我看到了不同的行为，也许任何人都可以解释为什么我没有看到我的重写在以下注释的情况下工作，在这种情况下，自定义取消分配没有被调用：
#include <iostream>
struct B {
void operator delete(void* ptr) {
std::cout << "B's operator delete" << std::endl;
::operator delete(ptr);
浏览 0提问于2019-04-08得票数 3
回答已采纳
一个非常简短的问题，但令人惊讶的是，我没有在网上找到任何东西：
我正在为一个类重载new和delete。我也需要重载new[]和delete[]，还是它们会自动“重定向”到重载的new和delete？
浏览 4提问于2015-07-09得票数 1
回答已采纳
在c++中，将new()和delete()实现为运算符的用途或原因是什么？让它成为运算符而不是函数有什么好处？
浏览 0提问于2012-11-21得票数 3
回答已采纳
我重载了全局操作符new/ delete / new[] /delete[]，但简单的测试表明，虽然我的new和delete版本被正确调用，但使用new[]和delete[]执行简单的数组分配和删除操作会导致调用newaop.cpp和delete2.cpp中的实现。
例如，下面的代码
int* a = new int[10];
在newaop.cpp中调用operator new[]，然后调用我的operator new版本。因此，它们似乎是全局重载的，但由于某些原因，数组版本不是。我是不是漏掉了什么？
编辑:我的运算符实现在一个单独的项目中，它被编译到一个库中，并静态链接到。回想起来，这可能
浏览 0提问于2010-01-18得票数 3
回答已采纳
2回答
当涉及到C++ /free时，我正试图在malloc/free中挂上新的/删除，这很简单:只需阅读它：
但是，如果在C++中使用new/delete进行分配呢？
附言:我的意思是G++/GCC
浏览 0提问于2015-10-15得票数 0
所谓可替换函数，我指的是类似于C++中的new和delete运算符，如果提供了用户提供的定义，这些运算符将被替换。
除了运算符new和delete (在C/C++中)之外，有没有一种合理的可移植方法可以在库中实现这一点？或者每个实现都需要单独解决这个问题？
对于一个具体的例子，让我们假设这个库包含：
int the_answer(void) {
return 42;
}
然后一个使用的程序会想要覆盖这个：
int the_answer(void) {
return 43;
}
int main() {
printf("The answer is %d\n
浏览 0提问于2015-10-21得票数 0
我在自己编写string类。我有这样的代码。我只想重载operator=。这是我的实际代码，我在代码的最后一部分得到了错误。
#include <iostream>
#include <string.h>
#include <stdlib.h>
using namespace std;
class S {
public:
S();
~S() { delete []string;}
S &operator =(const S &s);
private:
cha
浏览 0提问于2012-10-12得票数 25
回答已采纳
3回答
这个问题听起来可能有点奇怪，但我从来没有完全理解为什么我们需要有两种不同的语法来删除C++中的动态分配内存？
例如,
int *p = new int[10];
delete[] p; // why not just delete p;?
在普通的老C中，您只需使用free函数来释放分配给指针的内存，而不管分配的元素数量如何。当然，C++要复杂一些，因为它允许类类型调用它们的析构函数等等。但是，我认为使用单一语法删除C++中动态分配的内存没有任何障碍。
有什么根本原因决定使用两个版本，delete和delete[]？
更重要的是，如果您使用delete而不是delete[]，大多数编译器甚至都
浏览 8提问于2014-11-28得票数 0
回答已采纳
5回答
重载new/delete
、、、
我在我的程序中做了一个小的内存泄漏查找器，但是我重载new和delete (以及new[]和delete[])的方法似乎什么也做不了。
void* operator new (unsigned int size, const char* filename, int line)
{
void* ptr = new void[size];
memleakfinder.AddTrack(ptr,size,filename,line);
return ptr;
}
我重载new的方式如上面的代码片段所示。我猜是运算符返回void*的原因，但我不知道该怎么办。
浏览 1提问于2009-02-24得票数 28
回答已采纳
2回答
据我所知，有在C++中修改new和delete的行为：
替换默认的新/delete和new[]/delete[]Overriding或重载放置版本(覆盖传递给它的内存位置的版本)，在创建传递arguments)Overloading类特定版本的其他类型或数量的版本时重载。
对新/删除行为执行这些修改的限制是什么？
特别是，新的和删除的签名是否受到限制？
如果任何替换版本必须具有相同的签名(否则它们不会被替换，或者会破坏其他代码，例如STL )，这是有意义的，但是是否允许全局放置或特定于类的版本返回智能指针或一些自定义句柄？
浏览 4提问于2012-01-06得票数 4
回答已采纳
2回答
错误重载操作符'>>‘
、、、
我试图重载>>操作符，检查我的代码，这是最简化的程序：
#include <iostream>
#include <string>
using namespace std;
class MyClass{
private:
string bar;
int foo;
public:
MyClass(){
bar="";
foo=0;
};
istream& operator>>(istream& is){
is >> bar >> foo;
r
浏览 2提问于2016-06-17得票数 2
回答已采纳
请考虑以下代码和问题：
/*
* GCC 4.4
*/
#include <iostream>
using namespace std;
class A {
public:
void* operator new(size_t s) {
cout << "A::operator new(size_t) called\n";
}
void operator delete(void* p) {
cout << "A::operator delete(void*) called\
浏览 6提问于2011-11-21得票数 1
回答已采纳
2回答
void operator delete(void *p)
{
printf("\nDELETE");
// code to actually delete/free object
}
int _tmain(int argc, _TCHAR* argv[])
{
int *p = new int(10);
delete p;
getchar();
return 0;
}
我得到错误的操作符删除已经定义的
我想要覆盖新操作符和全局删除操作符。
浏览 3提问于2013-03-22得票数 0
1回答
我已经重载了新的和删除的操作符。我希望保存指向“new”和“delete”的指针，以便将其称为“新”new和delete。例如：
#include "h.h"
void * operator new ( size_t size, /*args*/ ) throw (std::bad_alloc)
{
void * p = 0;
p = original_new(size); //calling for 'old' new
//some code
return p;
}
以及类似的算子delete。
因此，我正在尝试在头文件中键入以
浏览 8提问于2011-12-19得票数 2
回答已采纳
我被告知“新表达式将多次调用operator new来管理动态存储并同时初始化对象”。我对此毫不怀疑。但是我想知道，既然operator new是在标准库头<new>中声明的，那么即使我们没有包含头文件，我们怎么能仍然使用新的表达式。
operator new是C++核心语言的一部分，还是编译器隐含地包含了<new>？
浏览 8提问于2016-08-22得票数 4
回答已采纳
我正在将我的游戏引擎从Java移植到C++。我做了很多关于自定义内存分配器的研究，因为我现在需要担心内存管理。我读过的每一篇关于这个主题的文章都说你应该重载new和delete操作符。但是，这些重载运算符通常只是委托和调用处理内存分配的自定义函数。此外，通常使用宏，例如：
#define New(className, size, description) customNew(className, size, description, __FILE__, __LINE__)
它甚至从不使用重载的new运算符，而只是调用自定义方法。我理解宏的用处，因为您可以很好地获取文件名和行号，但是如果在代码中
浏览 0提问于2012-07-19得票数 1
回答已采纳
我知道new和delete是关键词。
int obj = new int;
delete obj;
int* arr = new int[1024];
delete[] arr;
<new>报头是C++标准报头的一部分。它有两个运算符(我不确定它们是运算符还是函数)：
::operator new
::operator delete
这些运算符的用法如下：
#include <new>
using namespace std;
int* buff = (int*)::operator new(1024 * sizeof(int));
::operator delet
浏览 1提问于2012-05-09得票数 8
回答已采纳
在C中，为了确保所有结构都归零，我用以下命令包装malloc：
void* safe_malloc(size_t size){
void *result = malloc(size);
memset(result, 0, size); //NULL check ommitted for brevity
return result;
}
这样我就可以避免做以下事情：
struct Foo {
int bar;
int bat;
};
struct Foo *tmp = malloc(sizeof(struct Foo));
tmp->bar = 0
浏览 1提问于2014-04-23得票数 0
2回答
我正在用c++编写一个内存管理器。这样做的目的是在开始时使用malloc分配一定数量的内存，然后重载new和delete，以便它使用该内存。我几乎让它工作了，我唯一的问题是我如何跟踪内存中的位置。
我创建了一个结构的向量，它保存了诸如大小、位置以及它是否空闲等信息。
问题是当我调用push_back时，它试图使用我重载的新函数。这就是它失败的地方，因为它不能使用我的重载的new，直到它推回了第一个信息结构。
有谁知道我如何解决这个问题，或者有一个更好的方法来跟踪内存？
浏览 0提问于2011-12-24得票数 1
回答已采纳
通常，在C语言中，我们把printf和scanf看作是函数。当涉及到cout和cin时，在C++中它们是什么?我的意思是它们不可能是函数，因为它们后面没有括号，所以它们不是函数。那么什么是cout和cin是标准的输入和输出函数?还是别的什么？
浏览 0提问于2013-11-19得票数 16
4回答
对于在类C++数字类中实现算术运算符重载，有没有规范的或推荐的模式？
在C++常见问题解答中，我们有一个异常安全的赋值操作符，它可以避免大多数问题：
class NumberImpl;
class Number {
NumberImpl *Impl;
...
};
Number& Number::operator=(const Number &rhs)
{
NumberImpl* tmp = new NumberImpl(*rhs.Impl);
delete Impl;
Impl = tmp;
return *this;
}
但对于其他
浏览 11提问于2009-01-07得票数 7
回答已采纳
4回答
C++运算符重载
、、、
在C#中，重载任何运算符的方法(函数)必须是static和public。
我认为让它成为static是一件好事，每个对象都不需要它自己的版本。
但在C++中，它不一定是static。为什么C#强制这样做，而C++不这样做？
这两种设计的优缺点是什么？
浏览 0提问于2011-05-13得票数 1
回答已采纳
5回答
C++只允许重载=运算符作为成员函数，而不是全局函数。
Bruce Eckel说if it was possible to define operator= globally, then you might attempt to redefine the built-in = sign.，由于这个原因，你只能重载=运算符作为成员函数。
如果C++已经定义了=运算符，那么为什么还要定义+、-等其他运算符呢？不是由C++定义的，因为它们可以作为非成员函数重载。？
浏览 6提问于2012-01-04得票数 1
回答已采纳
我看到以下结构：
如果new X构造函数抛出，X将释放内存。
operator new()可以重载。
操作符新重载的规范定义是void *operator new(size_t c, heap h)和相应的operator delete。
最常见的操作符新重载是placement，即void *operator new(void *p) { return p; }。
您几乎总是无法在指定位置delete的指针上调用new。
这就引出了一个问题:当X构造函数抛出并使用重载的new时，如何清理内存？
浏览 0提问于2013-10-30得票数 13
回答已采纳
如果我这样做：
// (1.)
int* p = new int;
//...do something
delete p;
// (2.)
class sample
{
public:
sample(){}
~sample(){}
};
sample* pObj = new sample;
//...do something
delete pObj;
那么C++编译器如何知道delete后面的对象是内置数据类型还是类对象呢？
我的另一个问题是，如果我new一个指向int数组的指针，然后delete []，那么编译器如何知道要释放的内存块的大小？
浏览 1提问于2010-02-27得票数 6
回答已采纳
7回答
目前，我正在查看使用C++删除指针的::delete代码。
这方面的一个毫无意义的例子是：
void DoWork(ExampleClass* ptr)
{
::delete ptr;
}
以这种方式使用delete关键字的目的是什么？
浏览 1提问于2018-08-20得票数 8
回答已采纳
4回答
我尝试在C++中重载操作符，但遇到了一些困难。这就是我在班上的内容：
ostream & operator <<(ostream & s)
{
s << w();
return s;
}
string w()
{
stringstream ss;
string str;
for (int i=n-1; i>=0; i--)
{
if (i==n-1)
{
ss<<tablica[i] << "x^" << i;
}
else
{
浏览 0提问于2013-03-25得票数 0
回答已采纳
1回答
新/删除“覆盖”与“重载”
、、、、
我一直以为..。
重实现基类whereasoverloading中的函数(相同签名)意味着实现具有相同名称但签名不同的的函数。
..。因为有时候人们根本不关心区别。
关于新/删除:它们是重载还是重写？
一个想法：
在类= overloadreimplementing全局/delete=重写中实现新/删除操作符的
是否有任何更正/建议/反对意见？随便贴上“剪头发”这个问题..。
浏览 1提问于2010-09-18得票数 5
回答已采纳
4回答
我可以用不同的参数覆盖全局operator new，例如，我可以拥有：
void* operator new (std::size_t size) throw (std::bad_alloc);
void* operator new (std::size_t size, int num) throw (std::bad_alloc);
它可以单独调用为
int* p1 = new int; // calls new(size_t)
int* p2 = new(5) int; // calls new(size_t, int)
由于每种分配方案都可能使用不同的分配方案，因此我需要为每个分配方案提
浏览 12提问于2012-07-11得票数 7
回答已采纳
请参阅下列代码：
#include<iostream>
#include<stdlib.h>
#include<new>
using namespace std;
class ex
{
int x;
public:
ex():ex(0){}
ex(int x):x(x)
{
//cout<<"\nConstructor";
}
void *operator new(size_t siz)
{
void *p;
cout<<&#
浏览 8提问于2019-12-17得票数 3
回答已采纳
这就是我要做的：
#include <iostream>
using namespace std;
class Test
{
public:
int i;
Test();
Test(int x);
~Test();
static void operator delete(void * t);
};
Test::Test() : i(1) { cout << "constructing" << endl; }
Test::Test(int x) : i(x) { cout << &#
浏览 0提问于2013-07-10得票数 1
回答已采纳
4回答
在我从C++学到的所有东西中(其实不是很多)，操作符重载似乎是最难的。总而言之，什么时候最好写一个操作符重载作为友元函数？什么时候必须明确使用*this？使用临时对象总是不好吗？
浏览 1提问于2009-04-22得票数 2
回答已采纳
2回答
在C#中，要重载'+‘、'-’等运算符，我必须使函数成为类的静态成员：
class MyType
{
/*...*/
public static MyType operator+ (MyType a, MyType b)
{
MyType ret;
/* do something*/
return ret;
}
}
据我所知，在C++中，这是我重载操作符的方式：
class MyType
{
/*...*/
public:
MyType operator+ (MyType b) // *this
浏览 3提问于2012-09-06得票数 2
回答已采纳
我们可以在c++中声明这样的函数吗：
int operator + (int , int);
您的回答将不胜感激！
谢谢
浏览 14提问于2013-07-30得票数 23
回答已采纳
我可能遗漏了一些非常琐碎的东西，但是在调用任何delete或delete[]时，是否有一种暂停/中断调试器的方法？我尝试过Debug->New Breakpoint->Function断点(输入delete作为函数名)，但它并没有真正触发。
提前谢谢！
浏览 1提问于2019-01-23得票数 4
回答已采纳
5回答
我是C++的新手，还在努力掌握它的语法。我已经看了几个操作符重载的例子，最近的智能指针实现。下面是我正在查看的一个非常通用的示例：
template < typename T > class SP
{
private:
T* pData; // Generic pointer to be stored
public:
SP(T* pValue) : pData(pValue)
{
}
~SP()
{
delete pData;
}
T& operator* ()
浏览 1提问于2014-02-05得票数 40
我正在开发一个内存泄漏工具。在这里，我重载了new和delete运算符。它工作得很好。但是我创建这个工具的代码大约有15000行。我不能改变现有的代码，我只能在现有的代码中调用内存泄漏工具函数。具有stl容器的现有代码(如列表、映射、堆栈等)。Stl容器还调用new和delete运算符来分配或释放内存。我希望stl容器调用new和delete操作符，这两个操作符不是重载的new和delete。对于ex：
int *iptr = new int[10] ----> should call overloaded new[]
delete [] iptr -------------> s
浏览 0提问于2011-02-09得票数 3
3回答
我正在写一些“可移植”的代码(意思是它的目标是32位和64位的MSVC2k10和Linux上的GCC )，在其中我或多或少有：
typedef unsigned char uint8;
C字符串始终为uint8；这是出于字符串处理的原因。遗留代码需要char编译为带符号的，所以我不能将编译器开关设置为缺省为unsigned。但是如果我在处理一个字符串，我就不能很好地索引一个数组：
char foo[500];
char *ptr = (foo + 4);
*ptr = some_array_that_normalizes_it[*ptr];
在运行时，您不能在没有严重后果的情况下索引具有负数的
浏览 0提问于2011-12-22得票数 6
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
