char* str = new char [30]; // Allocate 30 bytes to house a string.
delete [] str; // Clear those 30 bytes and make str point nowhere.char* str = new char [30]; // Give str a memory address.
// delete [] str; // Remove the first comment marking in this line to correct.
str = new char [60]; /* Give str another memory address with
the first one gone forever.*/
delete [] str; // This deletes the 60 bytes, not just the first 30.char* str1 = new char [30];
char* str2 = new char [40];
strcpy(str1, "Memory leak");
str2 = str1; // Bad! Now the 40 bytes are impossible to free.
delete [] str2; // This deletes the 30 bytes.
delete [] str1; // Possible access violation. What a disaster!void Leak(int x){
char* p = new char [x];
// delete [] p; // Remove the first comment marking to correct.
}char* one = new char;
delete [] one; // Wrong
char* many = new char [30];
delete many; // Wrong!2.#include<iostream>using namespace std;class Base {public: virtual int fun(int i) { cout << "Base::fun(int i) called"; }};class Derived: public Base {private: int fun(int x) { cout << "Derived::fun(int x) called"; }};int main(){ Base *ptr = new Derived; ptr->fun(10); return 0;} Derived::fun(int x) called
In the above program, private function “Derived::fun(int )” is being
called through a base class pointer, the program works fine because
fun() is public in base class. Access specifiers are checked at compile
time and fun() is public in base class. At run time, only the function
corresponding to the pointed object is called and access specifier is
not checked. So a private function of derived class is being called
through a pointer of base class. #include<iostream>using namespace std;class Derived;class Base {private: virtual void fun() { cout << "Base Fun"; }friend int main();};class Derived: public Base {public: void fun() { cout << "Derived Fun"; }};int main(){ Base *ptr = new Derived; ptr->fun(); return 0;} |
Derived fun()
4.Deleting a derived class object using a pointer to a base class that has a non-virtual
destructor results in undefined behavior. To correct thissituation, the base class should be
defined with a virtual destructor. Making base class destructor virtual guarantees that the
object of derived class is destructed properly, i.e., both base class and derived class
destructors are called.
5. How does compiler do this magic of late resolution?Compiler maintains two things to this magic:
vtable: A table of function pointers. It is maintained per class.
vptr: A pointer to vtable. It is maintained per object (See this for an example).
Test(const Test &t) // class name Test2.Assignment Operator Test& operator = (const Test &t) // class name TestacquireLock();
Process Critical Section
releaseLock();
Static
|
Dynamic
|
Static libraries are compiled into the program itself.
|
Shared libraries are compiled separately and referenced by the program
|
Program size is smaller but shared libraries are required at the runtime.
|
|
Every program has its own static library
|
Shared library has only one copy and referenced by different programs
|
