Ich möchte den globalen new und delete operator überladen, um so memoryleaks ausfindig machen zu können. Leider will der Compiler meinen Code nicht und ich weiß auch mit der Fehlermeldung jetzt nicht wirklich was anzufangen. Der Code sieht wie folgt aus:

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#define DEBUG_NEW new( THIS_FILE, __LINE__)
#else
#define DEBUG_NEW new
#endif
#define new DEBUG_NEW

#ifdef _DEBUG

inline void * __cdecl operator new(unsigned int size,
                                   const char *file, int line)
{
	void *ptr = (void *)malloc(size);
	AddTrack((DWORD)ptr, size, file, line);
	return(ptr);
};
inline void __cdecl operator delete(void *p)
{
	RemoveTrack((DWORD)p);
	free(p);
};

#endif

und der Compiler (VC++ 6.0) sagt dazu folgendes:

error C2061: Syntaxfehler : Bezeichner 'THIS_FILE'

Die Fehlermeldung bezieht sich auf die Zeile mit der Deklaration des neuen new-Operators. Habt jemand eine Ahnung, wo das Problem liegt? Oder gibt es eine Möglichkeit sich die Präprozessorausgabe anzusahen?

Danke!
Karsten

inline void * __cdecl operator new(unsigned int size,
                                   const char *file, int line)

wird zu

inline void * __cdecl operator new( THIS_FILE, __LINE__)(unsigned int size,
                                   const char *file, int line)

#include <string>

using namespace std;

#ifdef _DEBUG

#include <windows.h>
#include <list>
#include <string>

void AddTrack(DWORD addr,  DWORD asize,  const char *fname, DWORD lnum);

void RemoveTrack(DWORD addr);

void DumpUnfreed();

extern int counter;

inline void * __cdecl operator new(unsigned int size,
                                   const char *file, int line, int dummy)
{
	char str[2048];
	sprintf( str, "allocated: %d : %d BYTES at %s (%d)\r\n", ++counter, size, file, line );

	OutputDebugString( str );

	void *ptr = (void *)malloc(size);
	AddTrack((DWORD)ptr, size, file, line);
	return(ptr);
};

inline void __cdecl operator delete(void *p)
{
	RemoveTrack((DWORD)p);
	free(p);
};

#undef DEBUG_NEW
#define DEBUG_NEW new( __FILE__, __LINE__, 1)
#else
#define DEBUG_NEW new
#endif
#define new DEBUG_NEW

@lolz: ich geb dir auf jeden Fall recht, dass der Stil nicht wirklich gut ist. Das ganze soll auch nur zur schnellen Fehlerbehebung dienen. Leider kann ich die von VC bereitgestellten Trackingfunktionen nicht benutzen, da ich an einem reinen plattfromunabhängigen C++-Projekt arbeite und VC lediglich die Entwicklungsumgebung unter Windows ist. Also kein AFX-irgendwas. Kleine Frage noch: wie würdest du die defines nennen? Ich hab mal in den VC-headern geguckt und die machen das fast genau so.

struct NewLogger
{
    NewLogger(const char* file, const char* Line) : file_( file ), line_( line ) {}
    const char* file_;
    const char* line_;
    template<typename T>
    T* operator%(T* p)
    {
        // Logging
        return p;
    }
};
#define new NewLogger(__FILE__,__LINE__)%new

da muss ich doch glatt mal ne dumme Frage stellen: was ist ein placement new? Entweder ist mir das noch nie so untergekommen, oder ich kenne es nicht. Würde mich über aufklärung freuen. Also was ist das und wann setzt man dies sinnvoller Weise ein?

Ausserdem hab ich noch ein Problem. Mein Logger funktioniert soweit, aber scheint nicht alles mitzubekommen, denn er spuckt weniger aus, als das was mir VC-Studio 6 anzeigt. Dummerweise bekomme ich von VC keine Informationen, wo der Speicher allociert wird. Hat jemand eine Idee, was man noch machen könnte, neben einem Logger?

void* operator new(size_t, void *mem)
{
   return mem;
}

Aufgerufen wird sie so:

new (buffer) T;

Ich meine alle überladen Versionen von new die einen Parameter mehr haben werden als placement new bezeichnet und die obige Version ist sogar in <new> mit dabei und man nennt diese den "placment new"...

Stell dir vor du hast bereits rohen Speicher bzw am Anfang deines Programmes zur Sicherheit einen Speicher-Block besorgt. Später willst du dann in diesen Speicherbereich dein Objekt Konstruieren und das geht dann mit placement new.

Wie du siehst tut placment new nichts anderes als den Speicher zurückzugeben.
Das reicht auch völlig aus den wenn new den operator new aufruft tut er ja dies um Speicher zu bekommen und dann reicht es ja aus deinen Speicher einfach wieder zurückzugeben.

Du kannst dir deine eigenen placement new's konstruieren die zB auch so aussehen.

void* operator new(size_t size, ostream& stream)
{
  stream << ......
  return ::operator new(size); // Einfach globalen op aufrufen ( hoffe das war so richtig :) )
}
//...
new (cout) T;

So kannst du dir dann alles direkt protokolieren.
Danach musst du aber auch placment delete benutzen da der Speicher ja nicht von newm, der sieht dann genau so aus mit einem Parameter mehr.

Vergiss nicht zu all deinen placement new's dann auch die richtigen placement delete's zu schreiben.

da muss ich doch glatt mal ne dumme Frage stellen: was ist ein placement new? Entweder ist mir das noch nie so untergekommen, oder ich kenne es nicht. Würde mich über aufklärung freuen. Also was ist das und wann setzt man dies sinnvoller Weise ein?

Zum Beispiel das hier:

new( __FILE__, __LINE__, 1) T;

Jeder new Ausruck, bei dem zusätzliche Argumente (in den runden Klammern) an den new-operator geliefert werden, benutzt placement-new. Die Bezeichnung ist Folge der typischen Benutzung: man möchte ein Objekt an einer bestimmten Stelle konstruieren, ohne extra Speicher anzufordern (d.h. man hat den Speicher bereits vorher angefordert). Das ist nützlich und notwendig zum Beispiel für Containerklassen. In diesem Standardfall des placement new (der als einziger auch tatsächlich von vornherein existiert) wird als zusätzliches Argument ein entsprechneder Pointer übergeben. zum Beispiel:

struct Foo {};
int main()
{
    Foo foo;          // legt ein Foo an, aber keine Initialisierung, da POD
    new(&foo) Foo();  // legt ein initialisiertes Foo an
};

in diesem Falle nat. nicht sehr nützlich. Bei Placement new wird ein entsprechend überladener new-operator aufgerufen, der die zusätzlichen Argumente als 2.,3. usw. Argument erhält. Interessant ist dabei, dass es kein placement-delete gibt (wohl aber plcement-delete operatoren, die aber nur bei exceptions während eines placement news oder eben explicit aufgerufen werden), im Normalfall will man ja das Objekt nur zerstören und benutzt dafür einen expliziten Destruktoraufruf.

Freak_Coder schrieb:

Danach musst du aber auch placment delete benutzen da der Speicher ja nicht von newm, der sieht dann genau so aus mit einem Parameter mehr.

Wie camper es sagt gibts aber ein placment delete das bei nicht erfolgreicher Speichernaforderung aufgerufen wird.

Dein placement delete musst die selben Parameter haben wie dein p-new, damit diese im Fehlerfall aufgerufen werden können.

Deine Objekt musst du dann selbst destruieren und danach deinen Speicher so freigeben wie du ihn auch besorgt hast.

#include <cstdlib>                                                                                                                                                       
#include <iostream>                                                                                                                                                      
using namespace std;                                                                                                                                                     

#if DEBUG                                                                                                                                                                         
void* operator new(size_t n) {                                                                                                                                           
    cout << "new of " << n << endl;                                                                                                                                      
    void*d = malloc(n);                                                                                                                                                  
    return d;                                                                                                                                                            
}                                                                                                                                                                        
void operator delete(void * p) {                                                                                                                                         
    cout << "Deleting object " << p << endl;                                                                                                                             
    free(p);                                                                                                                                                             
}                                                                                                                                                                        
void operator delete[](void * p) {                                                                                                                                       
    cout << "Deleting array" << p << endl;                                                                                                                               
    free(p);                                                                                                                                                             
}                                                                                                                                                                        

#endif                                                                                                                                                                   
main() {                                                                                                                                                                 
    char* x = new char[10];                                                                                                                                              

    delete[] x;                                                                                                                                                          
}

man darf new und delete durch eigenes ersetzen

es geht auch folgendes:

man darf new und delete durch eigenes ersetzen

Das stand nicht zur Debatte. Das einfache Überladen ist für unsere Zwecke aber nutzlos, weil wir zusätzliche Daten, die nur der Aufrufer kennt, benötigen.

@David_pb: falls du meinst, was ich mache wenn ich den new-Operator einer bestimmten Klasse überladen will, dann ist das nicht nötig! Alle new-Operatoren rufen irgendwann den globalen Operator auf den ich da überschreibe.

Sehr schlau ausgedacht. Es mag aber sein das du die Art der Speicherreservierung anders handhaben willst als bei deiner globalen Funktion operator new.

grüße