Valgrind ruft den überlasteten globalen Operator „New“ der Anwendung nicht auf ⇐ C++

[Anonymous]

Im folgenden kurzen Programm: Wenn es ohne Valgrind ausgeführt wird, wird der überladene globale New-Operator aufgerufen. Mit Valgrind wird er überhaupt nicht aufgerufen, stattdessen wird anscheinend der globale New-Operator von Valgrind aufgerufen. Meine Frage ist: Wie können wir Valgrind dazu bringen, das globale Neu/Löschen der Anwendung aufzurufen? (Valgrind 3.13.0; OS Linux, Ubuntu 14.04.5 LTS, x86_64) (Der überladene Operator der Anwendung kann den Speicher mithilfe von VALGRIND_MEMPOOL_ALLOC/VALGRIND_MEMPOOL_FREE-Makros als verwendet markieren, aber wir kommen nicht dorthin)
(Bearbeiten: Mit Valgrind 3.10.1 wird der globale neue Operator aufgerufen)

Code: Select all

#include 
#include 

void* operator new (size_t size_i) throw (std::bad_alloc)
{
fprintf(stderr,"new %d (operator new (size_t size_i) throw (std::bad_alloc))\n", __LINE__);
return malloc(size_i);
}

void* operator new (size_t size_i, const std::nothrow_t& nothrow_value) throw()
{
fprintf(stderr,"new %d (operator new (size_t size_i, const std::nothrow_t& nothrow_value) throw())\n", __LINE__);
return malloc(size_i);
}

void* operator new[] (size_t size_i) throw (std::bad_alloc)
{

fprintf(stderr,"new %d (operator new[] (size_t size_i) throw (std::bad_alloc)) \n", __LINE__);
return malloc(size_i);
}

void* operator new[] (size_t size_i, const std::nothrow_t& nothrow_value) throw()
{
fprintf(stderr,"new %d (operator new[] (size_t size_i, const std::nothrow_t& nothrow_value) throw()) \n", __LINE__);
return malloc(size_i);
}

void operator delete (void* p_i) throw()
{
fprintf(stderr, "delete %d (operator delete (void* p_i) throw())\n",__LINE__);
free(p_i);
}

void operator delete (void* p_i, const std::nothrow_t& nothrow_constant) throw()
{
fprintf(stderr, "delete %d\n",__LINE__);
free(p_i);
}

void operator delete[] (void* p_i) throw()
{
fprintf(stderr, "delete %d\n",__LINE__);
free(p_i);
}

void operator delete[] (void* p_i, const std::nothrow_t& nothrow_constant) throw()
{
fprintf(stderr, "delete %d\n",__LINE__);
free(p_i);
}

#include 

main()
{
fprintf(stderr, "ku !\n");

char * a = new char[123];
delete [] a;

int * b = new int();
delete b;

return 0;
}

Jetzt kompilieren

Code: Select all

gcc -g valg.cpp  -lstdc++

Führen Sie es ohne Valgrind aus

Code: Select all

$ ./a.out
ku !
new 19 (operator new[] (size_t size_i) throw (std::bad_alloc))
delete 43
new 6 (operator new (size_t size_i) throw (std::bad_alloc))
delete 31 (operator delete (void* p_i) throw())

Mit valgrind wird der globale Operator new nicht aufgerufen.

Code: Select all

valgrind ./a.out
==24181== Memcheck, a memory error detector
==24181== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==24181== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==24181== Command: ./a.out
==24181==
ku !
==24181==
==24181== HEAP SUMMARY:
==24181==     in use at exit: 0 bytes in 0 blocks
==24181==   total heap usage: 2 allocs, 2 frees, 127 bytes allocated
==24181==
==24181== All heap blocks were freed -- no leaks are possible
==24181==
==24181== For counts of detected and suppressed errors, rerun with: -v
==24181== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)