Return to Answer

fixed an error

edit approved May 1, 2020 at 17:06

user12117801

edit approved May 1, 2020 at 17:06

user12117801

A virtual constructor is not possible but virtual destructor is possible. Let us experiment.......

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

The construction of derived object follow the construction rule but when we delete the "b" pointer(base pointer) we have found that only the base destructor is called. But this must not be happen. To do the appropriate thing, we have to make the base destructor virtual. Now let see what happens in the following:

#include <iostream>
using namespace std;
class Base
{ 
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 virtual ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The output changed as following:

Base Constructor Called
Derived Constructor called
Derived destructor called
Base destructor called

So the destruction of the base pointer (which takes an allocation on derived object!) follows the destruction rule, i.e first the Derived, then the Base. On the other hand, there is nothing like a virtual constructor.

A virtual constructor is not possible but virtual destructor is possible. Let us experiment....

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

#include <iostream>
using namespace std;
class Base
{ 
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 virtual ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The output changed as following:

Base Constructor Called
Derived Constructor called
Derived destructor called
Base destructor called

A virtual constructor is not possible but virtual destructor is possible. Let us experiment.......

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

The construction of derived object follow the construction rule but when we delete the "b" pointer(base pointer) we have found that only the base destructor is called. But this must not happen. To do the appropriate thing, we have to make the base destructor virtual. Now let see what happens in the following:

#include <iostream>
using namespace std;
class Base
{ 
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 virtual ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The output changed as following:

Base Constructor Called
Derived Constructor called
Derived destructor called
Base destructor called

corrected spelling and grammar

Source Link

edit approved May 30, 2019 at 8:37

Community Bot

edit approved May 30, 2019 at 8:37

Community Bot

A virtual constructor is not possible but virtual destructor is possible. Let us experiment....

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

The construction of derived object follow the construction rule but when we delete the "b" pointer(base pointer) we have found that only the base destructor is callcalled.But But this must not be happenedhappen. To do the appropriate thing, we have to make the base destructor virtual. Now let see what happenhappens in the following:

#include <iostream>
using namespace std;
class Base
{ 
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 virtual ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The output changed as following:

Base Constructor Called
Derived constructorConstructor called
Derived destructor called
Base Destructordestructor called

So the destruction of the base pointer(which taketakes an allocation on derived object!) followfollows the destruction rule, i.e first the derivedDerived, then the baseBase. On the other hand for constructor, there areis nothing like a virtual constructor.

A virtual constructor is not possible but virtual destructor is possible. Let us experiment....

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

The construction of derived object follow the construction rule but when we delete the "b" pointer(base pointer) we have found that only the base destructor is call.But this must not be happened. To do the appropriate thing we have to make the base destructor virtual. Now let see what happen in the following:

#include <iostream>
using namespace std;
class Base
{ 
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 virtual ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The output changed as following:

Base Constructor Called
Derived constructor called
Derived destructor called
Base Destructor called

So the destruction of base pointer(which take an allocation on derived object!) follow the destruction rule i.e first the derived then the base. On the other hand for constructor there are nothing like virtual constructor.

A virtual constructor is not possible but virtual destructor is possible. Let us experiment....

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

#include <iostream>
using namespace std;
class Base
{ 
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 virtual ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The output changed as following:

Base Constructor Called
Derived Constructor called
Derived destructor called
Base destructor called

So the destruction of the base pointer(which takes an allocation on derived object!) follows the destruction rule, i.e first the Derived, then the Base. On the other hand, there is nothing like a virtual constructor.

Fix non-functional code example due to typo

Source Link

edit approved Mar 31, 2018 at 9:50

Daniel Carvalho

edit approved Mar 31, 2018 at 9:50

Daniel Carvalho

A virtual constructor is not possible but virtual destructor is possible. Let us experiment....

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1;Derived1();
 delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

#include <iostream>
using namespace std;
class Base
{ 
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 virtual ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new derived1;Derived1();
 delete b;
}

The output changed as following:

Base Constructor Called
Derived constructor called
Derived destructor called
Base Destructor called

A virtual constructor is not possible but virtual destructor is possible. Let us experiment....

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1;
 delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

#include <iostream>
using namespace std;
class Base
{ 
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 virtual ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new derived1;
 delete b;
}

The output changed as following:

Base Constructor Called
Derived constructor called
Derived destructor called
Base Destructor called

A virtual constructor is not possible but virtual destructor is possible. Let us experiment....

#include <iostream>
using namespace std;
class Base
{
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The above code output the following:

Base Constructor Called
Derived constructor called
Base Destructor called

#include <iostream>
using namespace std;
class Base
{ 
public:
 Base(){
 cout << "Base Constructor Called\n";
 }
 virtual ~Base(){
 cout << "Base Destructor called\n";
 }
};
class Derived1: public Base
{
public:
 Derived1(){
 cout << "Derived constructor called\n";
 }
 ~Derived1(){
 cout << "Derived destructor called\n";
 }
};
int main()
{
 Base *b = new Derived1();
 delete b;
}

The output changed as following:

Base Constructor Called
Derived constructor called
Derived destructor called
Base Destructor called

added 142 characters in body

Source Link

edited Aug 20, 2017 at 14:56

Donald Duck is with Ukraine

edited Aug 20, 2017 at 14:56

Donald Duck is with Ukraine

deleted 30 characters in body

Source Link

edited Jun 4, 2013 at 13:10

Tunvir Rahman Tusher

edited Jun 4, 2013 at 13:10

Tunvir Rahman Tusher

6.7k
2
40
33

removed the word not

Source Link

edit approved Apr 11, 2013 at 11:32

gda2004

edit approved Apr 11, 2013 at 11:32

gda2004

Correct derived ctor to eliminate ambiguity - it seems like derived destructor is called twice.

Source Link

edit approved Apr 9, 2013 at 20:02

Community Bot

edit approved Apr 9, 2013 at 20:02

Community Bot

Source Link

answered Apr 9, 2013 at 13:39

Tunvir Rahman Tusher

answered Apr 9, 2013 at 13:39

Tunvir Rahman Tusher

6.7k
2
40
33

lang-cpp

CollectivesTM on Stack Overflow

Return to Answer