Constructor and Destructor Functions

The compiler does not support the following destructor features:

When a class has a base class with a virtual destructor, its user-declared destructor is virtual
When a class has a base class with a virtual destructor, its implicitly-declared destructor is virtual

The compiler does not support the following constructor features:

Copy constructor is an unsupported feature. Example:

Listing: Example - Unsupported Copy Constructor



class C { int member;};
void f(void) {

    C c1;     

    C c2 = c1;

-------^-----------ERROR: Illegal initialization of non-aggregate type

}

Using a non-explicit constructor for an implicit conversion (conversion by constructor) is unsupported. Example:

Listing: Example - Unsupported Usage of Non-Expilcit Constructor



class A{
public:

      int m;

      S(int x):m(x){};

};

int f(A a) {return a.m};

int b = f(5) /*value of b should be 5 because of explicit conversion of 
f parameter(b = f(A(5)))*/

Directly invoking a virtual member function defined in a derived class using a constructor/destructor of class x is unsupported. Example:
Listing: Example - Unsupported Direct Invoking of a Virtual Function
```
class A{
      int m;

      virtual void vf(){};

      A(int) {vf()}	

}

class B: public A{

      void vf(){}

      B(int i) : A(i) {}

}

B b(1); // this should result in call to A::vf()
```

Indirectly invoking a virtual member function defined in a derived class using a constructor of class x is unsupported. Example:

Listing: Example - Unsupported Indirect Invoking of a Virtual Function



class A{
      int m;

      virtual void vf(){};

      void gf(){vf();}

      A(int) {gf();}

}

class B: public A{

      void vf(){}

      B(int i) : A(i) {}

}

B b(1); // this should result in call to A::vf()

Invoking a virtual member function defined in a derived class using a ctor-initializer of a constructor of class x is unsupported. Example:

Listing: Unsupported Invoking of a Virtual Function Defined in Derived Class



class A{
      int m;

      virtual int vf(){return 1;};

      A(int):m(vf()){}

}

class B: public A{

      int vf(){return 2;}

      B(int i) : A(i) {}

}

B b(1); // this should result in call to A::vf()