C++ 处理内存分配时的保护标志
在下面的代码中,我很难理解守卫标志C++ 处理内存分配时的保护标志,c++,c,memory-management,memory-leaks,include-guards,C++,C,Memory Management,Memory Leaks,Include Guards,在下面的代码中,我很难理解守卫标志 // User-defined operator new. void *operator new( size_t stAllocateBlock ) { static int fInOpNew = 0; // Guard flag. if ( fLogMemory && !fInOpNew ) { fInOpNew = 1; clog <
// User-defined operator new.
void *operator new( size_t stAllocateBlock ) {
static int fInOpNew = 0; // Guard flag.
if ( fLogMemory && !fInOpNew ) {
fInOpNew = 1;
clog << "Memory block " << ++cBlocksAllocated
<< " allocated for " << stAllocateBlock
<< " bytes\n";
fInOpNew = 0;
}
return malloc( stAllocateBlock );
}
//用户定义的运算符新建。
void*运算符新(大小\u t stAllocateBlock){
static int fInOpNew=0;//保护标志。
如果(fLogMemory&!fInOpNew){
fInOpNew=1;
阻塞据我所知,这是一种避免多线程对日志流进行阻塞的尝试
假设两个线程同时调用该函数。打印的消息将混合(取决于运行时使用的缓冲机制)
为了避免这种情况,程序员创建了一个static
标志。函数的局部静态变量在所有调用中共享
其目的是,当一个调用记录消息时,它将首先将标志设置为1。这将不允许其他线程进入。(请参阅if!fInOpNew)
打印完成后,会将标志设置回0
虽然这种机制在避免竞态条件不起作用。因为两个线程可以进入if条件,然后可以设置标志
程序员需要使用原子原语,如比较和交换,以确保保护关键部分
另外,使用静态变量也不安全。如果两个线程同时向其写入数据,它可能会得到一个不等于0或1的值
编辑:正如托比·斯佩特(Toby Speight)所建议的,标志的另一个目的是避免再次进入。
我习惯于在大学里的练习中这样的“保护”,在练习中,人们必须说明为什么这不起作用,从而获得一个基本的理解,即即使变量=值也不是一个原子操作(好吧,在发布代码的情况下,正如你所说的,还有很多错误)我认为这更可能是为了避免重入(和无限递归)当clog.operatorOh时,这就更有意义了。你能检查我的代码并向我建议我们可以改进的地方吗?还有,如何保护这段代码不受多线程的影响?是的,delete有完全相同的原因。现在,对于第二部分,如果你想让它对多线程安全,你可以将日志部分封装在互斥锁/sem中aphores。它们可以用来抵御种族条件
/*
* Memory leak detector
*/
#include <iostream> // for cout, clog
#include <new> // for size_t
using std::clog;
using std::cout;
/* Logging toggle, 0x0 - No, 0xFF - Yes */
char logMemory;
/* Number of Memory blocks allocated */
int memoryBlocksAllocated;
void* AllocateMemory(size_t size)
{
/*
* Guard flag for protecting from reentrancy (recursion),
* as clog also make use of new operator for
* allocating memory to the buffer.
*/
static char InOperationNew = 0x0;
if ( logMemory && !InOperationNew ) {
InOperationNew = 0xFF;
clog << "Memory block allocated " << ++memoryBlocksAllocated
<<" for requested size " << size << " bytes\n";
InOperationNew = 0x0;
}
return malloc(size);
}
void ReleaseMemory(void *ptr)
{
/*
* Guard flag for protecting from reentrancy (recursion),
* as clog also make use of new operator for
* allocating memory to the buffer.
*/
static char InOperationDelete = 0x0;
if ( logMemory && !InOperationDelete ) {
InOperationDelete = 0xFF;
clog << "Memory block deallocated " << memoryBlocksAllocated-- << "\n";
InOperationDelete = 0x0;
}
free(ptr);
}
/* User defined(overriden) global scope new operator */
void* operator new (size_t size)
{
return AllocateMemory(size);
}
/* User defined(overriden) global scope new[] array operator */
void* operator new[] (size_t size)
{
return AllocateMemory(size);
}
/* User defined(overriden) global scope delete operator */
void operator delete (void *ptr)
{
ReleaseMemory(ptr);
}
/* User defined(overriden) global scope delete[] array operator */
void operator delete[] (void *ptr)
{
ReleaseMemory(ptr);
}
int main()
{
logMemory = 0xFF; // Enable logging
// Allocate and destroy an array of objects
char *objArray = new char[2];
if ( objArray )
{
delete[] objArray;
}
else {
cout << "Memory allocation failed\n";
return -1;
}
// Allocate and destroy an object
char *obj = new char;
if ( obj )
{
delete obj;
}
else {
cout << "Memory allocation failed\n";
return -1;
}
logMemory = 0x0; // Disable logging
return 0;
}