InfoLinux

Para usar la gestión de memoria "tipo C++" hay que llamar al new no sobreescrito hay que usar el operador :: (resolución de ámbito o "scope") como quieres llamar al new "global" no tienes que especificar nombre de clase ni namespace (ver el ejemplo)

Por otro lado está bien saber como se sobreescribir operadores, pero hay que tener una buena razón para ello, porque a alguein que no conozca el código puede ser ilegible (en particular esos operadores new, delete que tienen un comportamiento bien definido si no están sobreescritos... )

Un saludo y gracias por el esfurzo en tu artículo


ejemplo:

#include <stdio.h>
#include <iostream>
using namespace std;
class A
{
public:
void* operator new(size_t)
{
cout<<"constryendo uno (sobreescrito)"< return ::new A;
}


void* operator new[] (size_t siz)
{
cout<<"constryendo vector (sobreescrito), tamaño "<< siz < return ::new A[siz];
}

};
int main ()
{
A* a= new A[25];
A* b= new A;
}

me temo que la info de mi comentario anterior no es del todo válida, voy a investigar un poquito... :)

En el ejemplo anterior el problema es que se llamaba al operador global dentro del operador sobreescrito, con lo que se pasaba dos veces por el constructor (y no estoy seguro que no se pierda memoria, habría que comprobarlo...)

eso si se puede evitar usar el gestor de memoria sobreescrito si se llama a ::new y ::delete (para más dificultad de uso aún :) )

En general sobrecargar new y delete sirve para hacer gestion distinta a la normal del heap, por ejemplo hacer un gestor que coja mucha memoria al pricipio y vaya repartiéndola a los que la vayan pidiendo. Le veo poca utilidad en la mayoría de los casos...
(por aquí hay alguien que sabe de que va y no le gusta mucho...: http://www.scs.stanford.edu/~dm/home/papers/c++-ne...)

hacer un gestor de memoria de una clase con new y delete (sencillo y muy poco útil) sería:

#include <stdio.h>
#include <iostream>
using namespace std;
class A
{
public:
static int i;
int ii;
A()
{
ii=i++;
cout<<"construyendo... "<< i<<" "< }
~A()
{
ii=i--;
cout<<"destruyendo... "<< i<<" "< }

static void* operator new(size_t t)
{
cout<<"constryendo uno (sobreescrito)"< return new char[t];
}


static void* operator new[] (size_t siz)
{
cout<<"constryendo vector (sobreescrito), tamaño "<< siz < return ::new char[siz];
}
static void operator delete(void *point)
{
cout<<"destryendo uno (sobreescrito)"< ::delete (char*)point ;
}


void operator delete[] (void * point)
{
cout<<"destryendo vector (sobreescrito)"< ::delete [] (char*)point;
}




};
int A::i=0;
int main ()
{
A* a= new A[10];
A* b= new A;
A* c= ::new A;
for(int i=0;i<10;++i)
cout< delete []a;
delete b;
::delete c;

return 0;
}

>Insisto que si os parece bien, dejéis algún que >otro comentario.

A mi me parece de puta madre ;)

Por último, y como curiosidad

en la primera versión hacía -> return ::new char[siz];

algo que yo no sabía es que en el parámetro tipo size_t del new te viene el tamaño en bytes de lo que se va a alojar, con lo que

A* a= new A[25];

le pasaba un siz al new que es el número de bytes. Total que debería poner (para que el número sea el mismo)
return ::new char[siz/sizeof(A)];

de todos modos pasaría dos veces por el constructor, porque (no lo sabía) el cada new significa pasar por el constructor. Si se tienen datos de la clase (estáticos) y se cambian en las construcción (una cuenta de referencias, como en el ii del segundo ejemplo) puede dar comportamientos inesperados. Pero no perdía memoria...

Como viene a decir el artículo que menciono en el tercer comentario, una cosa es la gestion de memoria y otra la inialización (o destrucción) cosa que en C++ está un poco ligada...

Creo que he liado más que ayudado, lo siento O:)

Hola:

Yo he usado la sobrecarga de new y delete globales para hacer contabilidad de memoria reservada y liberada, con la intención de ver en qué partes del ćodigo se olvida hacer los delete.

Simplemente se hace una pequeña librería compilada con estas dos funciones. Si enlazas tu ejecutable con ella, tienes contabilidad de punteros. Si no la enlazas, no la tienes. Es una forma cómoda y rápida de sin tener que tocar en absoluto código -sólo hay que linkar-, ver dónde se pierde esa memoria.

En cuanto a usar malloc(), lo hago porque estoy redefiniendo new. Si uso new dentro de new, tengo recursión infinita. No he probado si llamando a ::new en vez de new se evita esa recursión, pero ... ¿no es lo mismo ::new que new a secas?.

Cada clase puede sobreescribir su propio new y delete, pero eso no me sirve para contabilidad global de punteros, además de que si quieres poner o quitar, tienes que tocar el código. La contabilidad de punteros es una cosa temporal y mientras se está desarrollando.

Se bueno.