Advance Tools and Techniques
Overloading new and delete
Specialized operators can give more flexibility in how
and when memory allocation and de-allocation occur
Run-Time Type Identification
Can obtain type specific information from an object
Can allow access to derived class methods and
members through a pointer/reference to a base class
Pointer to Class Member
Can be used to identify a data member or a member
function or operator within an object
CSE 332: C++ Advanced Tools and Techniques
Operators new and delete are Inverses
string *sp = new string ("a value");
string *arr = new string[10];
Three steps occur when new is called
A library function named operator new (or operator new[]) is called,
which allocates raw, untyped memory from the heap
Placement version of new is passed pointer to existing memory, and skips this step
The appropriate constructor(s) is(are) called to construct the object(s) from
the initializers
A pointer to the newly allocated and constructed object is returned as the
expressions value
delete sp;
delete [] arr;
Three steps occur when delete is called (inverse of for new)
A pointer to the memory to be de-allocated is passed as a parameter
A destructor is run at the position (version without []) or destructors are run
at all positions (version with []) to the parameter points
Memory is returned to the heap by calling library function operator delete
or operator delete[]
CSE 332: C++ Advanced Tools and Techniques
Interfaces for Operators new and delete
// might throw
void *operator
void *operator
void *operator
void *operator
an exception
new(size_t);
new[](size_t);
delete(void*) noexcept;
delete[](void*) noexcept;
// promise not
void *operator
void *operator
void *operator
void *operator
to throw
new(size_t, nothrow_t&) noexcept;
new[](size_t, nothrow_t&) noexcept;
delete(void*, nothrow_t&) noexcept;
delete[](void*, nothrow_t&) noexcept;
// placement new operators dont allocate: just call
// constructor(s) starting at passed address, return it
void *operator new(size_t, void*); // cant redefine
void *operator new[](size_t, void*);
CSE 332: C++ Advanced Tools and Techniques
Implementations of Operators new and delete
// From LLM pp. 823
void *operator new(size_t size) {
if (void *meme = malloc(size))
return meme;
else
throw bad_alloc();
}
void operator delete (void *meme) noexcept {
free (meme);
}
CSE 332: C++ Advanced Tools and Techniques
Run-Time Type Identification
The dynamic_cast operator returns a pointer or reference to a more specific
(derived) type if it can
Only can be used with pointers to structs or classes with virtual methods
The dynamic_cast operator returns nullptr (or throws an exception) if it cannot downcast
to the specified type
dynamic_cast<type*> (base) // returns a pointer
dynamic_cast<type&> (base) // returns an l-value reference
dynamic_cast<type&&> (base) // returns an r-value reference
The typeid operator returns a type_info for a given expression
Works with built-in types as well as user-declared types
Cannot declare or construct type_info objects explicitly
Can only use implicitly via expressions involving the typeid operator and operators and
methods available for type_info objects, e.g.,
cout << "e is of type " << typeid(e).name() << endl;
cout << " f is of type " << typeid(f).name() << endl;
cout << " the types are " <<
(typeid(e) == typeid(f) ? " " : " not ") <<
"the same" << endl;
CSE 332: C++ Advanced Tools and Techniques
Run-Time Type Identification Example
bool same_cage (Animal * a, Animal * b) {
// only ok if both are Pandas
return dynamic_cast<Panda *>(a) &&
dynamic_cast<Panda *>(b);
}
Output:
We have a struct Grizzly
and a struct Panda
Dont put in same cage!
int main (int, char * []) {
Animal *a = new Grizzly ();
Animal *b = new Panda ();
cout << "we have a "
<< typeid(*a).name() << endl << "and a "
<< typeid(*b).name() << endl << endl;
if (!same_cage(a, b)) {
cout << "Dont put in same cage!" << endl;
}
delete a; delete b;
return 0;
}
CSE 332: C++ Advanced Tools and Techniques
Pointer to Data Member
struct Truck {
Truck (unsigned int w): weight_(w) {
cout << "weight: " << weight_ << endl;}
unsigned int weight_;
};
int main (int, char * []) {
Truck trucks [] = {902, 900};
auto weight_ptr = &Truck::weight_; // data
Output:
weight: 902
weight: 900
Truck weights are:
Truck 0 weight is 902
Truck 1 weight is 900
cout << "Truck weights are: " << endl;
for (Truck* truck_ptr = trucks;
truck_ptr - trucks <
sizeof(trucks)/sizeof(Truck);
++truck_ptr) {
cout << "Truck " << truck_ptr - trucks
<< " weight is "
<< truck_ptr->*weight_ptr
<< endl;
}
return 0;
}
CSE 332: C++ Advanced Tools and Techniques
Pointer to Member Function
class Truck {
public:
Output:
Truck (unsigned int w): weight_(w) {
cout << "weight: " << weight_ << endl;}
weight: 902
unsigned int weight() {return weight_;}
weight: 900
private:
Truck weights are:
unsigned int weight_;
Truck 0 weight is 902
};
Truck 1 weight is 900
int main (int, char * []) {
Truck trucks [] = {902, 900};
// declaration almost identical to previous
auto weight_ptr = &Truck::weight; // fxn
cout << "Truck weights are: " << endl;
for (Truck* truck_ptr = trucks;
truck_ptr - trucks <
sizeof(trucks)/sizeof(Truck);
++truck_ptr) {
cout << "Truck " << truck_ptr - trucks
<< " weight is "
<< (truck_ptr->*weight_ptr)() << endl; // note how parens are used
}
return 0;
}
CSE 332: C++ Advanced Tools and Techniques
