Re: what is the difference between new and opeartor new.
On Feb 17, 7:41 am, sukhpal <sukhb...@gmail.com> wrote:
Can any please let me know the difference between new and
operator new.
Not an easy question to answer, because the vocabulary is a bit
confusing. Basically, `new', on it's own, is a keyword
representing an operator in the language. As such, it occurs in
two contexts: in an expression, it introduces a new expression,
which calls an allocator function to allocate memory, and then
initializes it. The initialization can be a no-op in certain
degenerate cases, but if the object(s) created have class type,
it calls the constructor. The keyword can, however, appear
after the keyword `operator', in which case, the sequence
`operator new' designates an allocator function, which may be
called (if chosen by overload resolution) by a new expression
(but which can also be called explicitly, e.g.
void* p = operator new( sizeof( T ) ) ;
..)
In order to avoid ambiguity, I avoid the expression `operator
new'. If I'm speaking of a type of expression, I'll just say
'new', or `the new operator'; if I'm speaking of the allocator
function, I'll say so explicitly, e.g. `the operator new
function'.
i have written follwoing example in which i have overloaded
new operator.
Overloaded, or replaced the standard one?
When i am using "void *p = operator new(1);" it doesn't call
the new overloaded operator.
It should use overload resolution to select which `operator new'
function is called. If yours takes a single int, then it should
be selected. If it takes another arithmetic type, the call
should be ambiguous, and otherwise, it should call the standard
one (which can be replaced).
So waht is operator new.When we use it?
#include <iostream>
#include <cstdlib>
#include <new>
using namespace std;
class MyClass
{
int x, y;
public:
MyClass() {
x = y = 0;
}
MyClass(int lg, int lt) {
std::cout << "in a constructor";
x = lg;
y = lt;
}
void show()
{
cout << x << " ";
cout << y << endl;
}
void *operator new(size_t size);
void operator delete(void *p);
void *operator new[](size_t size);
void operator delete[](void *p);
Note that the above are static members of MyClass, and will only
be considered in a new expression if it has type MyClass. They
do not replace the standard operator new (but they can be called
like any static member function, i.e.:
void* p = MyClass::operator new( 1 ) ;
..)
};
// overloaded new operator
void *MyClass::operator new(size_t size)
{
std::cout << "in a operator new";
void *p;
cout << "In overloaded new.\n";
One additional remark: DON'T do this in a global operator new
which replaces the standard one. The operator<< may itself use
new, in which case, you could easily end up in an endless
recursion.
If you want to instrument the global operator new (and it can
be very useful for debugging), then use a static variable to
protect against recursion, e.g.:
static int recursing = 0 ;
if ( recursing ++ == 0 ) {
std::cout << ... ;
}
-- recursing ;
p = malloc(size);
if(!p) {
bad_alloc ba;
throw ba;
}
return p;
}
// delete operator overloaded
void MyClass::operator delete(void *p)
{
cout << "In overloaded delete.\n";
free(p);
}
[...]
int main()
{
MyClass *objectPointer1, *objectPointer2;
int i;
void *p = operator new(1);
This should call the global operator new.
try {
objectPointer1 = new MyClass (10, 20);
This should call your operator new.
} catch (bad_alloc xa) {
cout << "Allocation error for objectPointer1.\n";
return 1;;
}
try {
objectPointer2 = new MyClass [10]; // allocate an arr=
ay
And this should call your operator new[].
} catch (bad_alloc xa) {
cout << "Allocation error for objectPointer2.\n";
return 1;;
}
objectPointer1->show();
for( i = 0; i < 10; i++)
objectPointer2[i].show();
delete objectPointer1; // free an object
delete [] objectPointer2; // free an array
int ruk;
std::cin >> ruk;
return 0;
}
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34