operator new global ve sınıf için olmak üzere ikiye ayrılır. Global operator new metodunu çağırmak için şöyle
Effective C++ 55'e göre operator new şöyle çalışır.
When operator new is unable to fulfill a memory request, it calls the new-handler function repeatedly until it can find enough memory.
A well-designed newhandler function must do one of the following:
- Make more memory available.
- Install a different new-handler.
- Deinstall the new-handler
- Throw an exception
- Not return
pseudo kod olarak metod şuna
benzer.
while (true) {
//attempt to allocate size bytes
if (the allocation was successful)
return (a pointer to the memory);
// allocation was unsuccessful; find out what the
// current new-handling function is
new_handler globalHandler = set_new_handler(0);
set_new_handler(globalHandler);
if (globalHandler) (*globalHandler)();
else throw std::bad_alloc();
}
new_handler bir function pointer olarak tanımlıdır. Gerçek kod ise
şöyle. Tüm algoritmanın nasıl çalıştığı şöyle
anlatılıyor. Açıklaması
şöyle
In case of failure, the standard library implementation calls the function pointer returned by std::get_new_handler and repeats allocation attempts until new handler does not return or becomes a null pointer, at which time it throws std::bad_alloc.
Thread Safe
Global operator new thread safe. Açıklaması
şöyle.
For purposes of determining the existence of data races, the library versions of operator new, user replacement versions of global operator new, the C standard library functions aligned_alloc, calloc, and malloc, the library versions of operator delete, user replacement versions of operator delete, the C standard library function free, and the C standard library function realloc shall not introduce a data race ([res.on.data.races]). Calls to these functions that allocate or deallocate a particular unit of storage shall occur in a single total order, and each such deallocation call shall happen before the next allocation (if any) in this order.
Operator New ve void *
void * C++'ta pek kullanılmaz. operator new bu kullanım yerlerinden bir
tanesi.
Operator New'e Geçilen size_t Büyüklüğü
Kurallar
şöyle.
1. Derleyici sınıf için sizeof(T) geçer. Bellek ayıran kod parçası yani operator new belleği yönetebilmek için talep edilenden biraz daha büyük bir alan ayırır.
2. Derleyici sınıf dizisi için N * sizeof(T)'den
biraz daha büyük bir alan geçer. Buradaki amaç dizi içinde kaç tane nesne olduğunu takip etmek ve dolayısıyla kaç defa destructor çağrılacağını bulmaktır. Bellek ayıran kod parçası yani operator new belleği yönetebilmek için yine talep edilenden biraz daha büyük bir alan ayırır.
When a new-expression calls an allocation function and that allocation has not been extended, the new-expression passes the amount of space requested to the allocation function as the first argument of type std::size_t. That argument shall be no less than the size of the object being created; it may be greater than the size of the object being created only if the object is an array.
Elimizde şöyle bir sınıf olsun ve array için operator new metodunu override etmiş olalım. Sınıfın destructor metodu olduğuna
dikkat!
struct foo {
static void* operator new[](std::size_t sz) {
return malloc(sz); //0x...16FO döndürür
}
static void operator delete[](void* ptr) {
free(ptr);
}
virtual ~foo() {}
};
Foo sınıfını şöyle çağıralım.
new foo[10]; //0x...16F8 alırım
Bu çağrı sonucunda sz parametresinin 10 tanelik bir dizi için gereken 80 byte'tan daha büyük bir değer ile çağrıldığını görebiliriz. Yani derleyici kendisi için kullanmak üzere 80 byte'tan daha büyük bir alan talep etmiştir.
Sınıf için Operator Newoperator new - Sınıf İçin (Raw Bellek Alanı) yazısına taşıdım.
Şöyle
yaparız.
class A
{
public:
void* operator new(std::size_t sz);
void operator delete(void* ptr);
};
Bir sınıf için operator delete metodunun boş olması bu sınıfın belleğinin halen kullanılabileceği anlamına gelmez. Elimizde şöyle bir sınıf
olsun
struct Foo {
int a;
static void operator delete(void* ptr) {}
Foo(): a(5) {}
~Foo() { std::cout << "Destructor called\n"; }
void doSomething() { std::cout << __PRETTY_FUNCTION__ << "a = " << a << " called\n"; }
};
Bu sınıfı şöyle
kullanalım
Foo* foo = new Foo();
delete foo;
foo->doSomething(); // safe?
Çıktı olarak şunu
alırız. Çunkü sınıfın destructor'ı bir kere çağrılırsa tüm alanları için de destructor çağrılır. Bu durumda alanlara erişmek undefined behavior'a (UB) sebep olur.
Destructor called
void Foo::doSomething() a= 566406056 called
Sınıf için Operator New Array
Şöyle yaparız
struct foo {
void* operator new[](std::size_t sz) {
...
}
static void operator delete[](void* ptr) {
...
}
};
Global Operator New Overload
Bir kere bile bu işi yapmam gerekmedi. Metod imzaları
şöyle. Hem operator new hem de karşılık gelen delete'leri verdim.
void* operator new (std::size_t size) throw (std::bad_alloc);
void* operator new (std::size_t size, const std::nothrow_t& nothrow_value) throw();
void* operator new (std::size_t size, void* ptr) throw();
void* operator new[] (std::size_t size) throw (std::bad_alloc);
void* operator new[] (std::size_t size, const std::nothrow_t& nothrow_value) throw();
void* operator new[] (std::size_t size, void* ptr) throw();
void operator delete (void* ptr) throw();
void operator delete (void* ptr, const std::nothrow_t& nothrow_constant) throw();
void operator delete (void* ptr, void* voidptr2) throw();
void operator delete[] (void* ptr) throw();
void operator delete[] (void* ptr, const std::nothrow_t& nothrow_constant) throw();
void operator delete[] (void* ptr, void* voidptr2) throw();
Global Operator New Overload
global operator new ise şöyle
yazılırak override edilir. blah blah yazan yere istenen tip konulur.
void* operator new (std::size_t size, optional blah blah here) blah blah here
Bir kere bile bu işi yapmam gerekmedi. Eğer array için new override edilirse, delete de override edilmeli. Metod imzaları şöyle
olabilir.
void* operator new[] (std::size_t size) throw (std::bad_alloc);
void* operator new[] (std::size_t size, const std::nothrow_t¬hrow_value)throw()
void* operator new[] (std::size_t size, void* ptr) throw();
void operator delete[] (void* ptr) throw();
void operator delete[] (void* ptr, const std::nothrow_t& nothrow_constant)throw();
void operator delete[] (void* ptr, void* voidptr2) throw();
Ya da şöyle
olabilir..
Derleyicisine göre denemek gerekiyor.
