What will be the output of the following program?

#include<iostream.h> 
class Base
{
    int x, y; 
    public:
    Base() 
    {
        x = y = 0; 
    } 
    Base(int xx)
    {
        x = xx;
    }
    Base(int p, int q = 10)
    {
        x = p + q;
        y = q; 
    } 
    void Display(void)
    {
        cout<< x << " " << y << endl;
    } 
}objDefault(1, 1);

class Derived: public Base
{
    Base obj; 
    public:
    Derived(int xx, int yy): Base(xx, xx + 1)
    { }
    Derived(Base objB = objDefault)
    { } 
}; 
int main()
{
    Derived objD(5, 3);
    Derived *ptrD = new Derived(objD);
    ptrD->Display();
    delete ptrD;
    return 0; 
}

#include<iostream.h> 
class Tab
{
    int x, y; 
    public:
    void show(void);
    void main(void);
};
void Tab::show(void)
{ 
    Tab b;
    b.x = 2;
    b.y = 4;
    cout<< x << " " << y;
}
void Tab::main(void)
{
    Tab b;
    b.x = 6; 
    b.y = 8;
    b.show();
}
int main(int argc, char *argv[])
{
    Tab run;
    run.main();
    return 0; 
}

#include<iostream.h> 
class CuriousTab
{
    int K; 
    public:
    void CuriousTabFunction(float, int , char);
    void CuriousTabFunction(float, char, char);
    
};
int main()
{
    CuriousTab objIB;
    objIB.CuriousTabFunction(15.09, 'A', char('A' + 'A'));
    return 0;
}
void CuriousTab::CuriousTabFunction(float, char y, char z)
{
    K = int(z);
    K = int(y);
    K = y + z;
    cout<< "K = " << K << endl; 
}

#include<iostream.h> 
class Addition
{
    int x; 
    public: 
    Addition()
    {
        x = 0;
    }       
    Addition(int xx)
    {
        x = xx;
    }
    Addition operator + (int xx = 0)
    {
        Addition objTemp; 
        objTemp.x = x + xx; 
        return(objTemp);
    }
    void Display(void)
    {
        cout<< x << endl;
    }
};
int main()
{
    Addition objA(15), objB;
    objB = objA + 5;
    objB.Display();
    return 0; 
}

#include<iostream.h>
int CuriousTabTest(int x, int y);
int CuriousTabTest(int x, int y, int z = 5);
int main()
{
    cout<< CuriousTabTest(2, 4) << endl; 
    return 0;
}
int CuriousTabTest(int x, int y)
{
    return x * y;
}
int CuriousTabTest(int x, int y, int z = 5)
{
    return x * y * z; 
}

#include<iostream.h> 
class Base
{
    public:
    char S, A, M; 
    Base(char x, char y)
    {
        S = y - y;
        A = x + x; 
        M = x * x;
    }
    Base(char, char y = 'A', char z = 'B')
    {
        S = y;
        A = y + 1 - 1; 
        M = z - 1;
    }
    void Display(void)
    {
        cout<< S << " " << A << " " << M << endl;
    }
};
class Derived : public Base
{
    char x, y, z; 
    public:
    Derived(char xx = 65, char yy = 66, char zz = 65): Base(x)
    {
        x = xx; 
        y = yy;
        z = zz;
    }
    void Display(int n)
    {
        if(n)
            Base::Display(); 
        else
            cout<< x << " " << y << " " << z << endl; 
    }
};
int main()
{
    Derived objDev; 
    objDev.Display(0-1); 
    return 0;
}

#include<iostream.h> 
class CuriousTab
{
    int x; 
    float y; 
    public:
    void CuriousTabFunction(int = 0, float = 0.00f, char = 'A');
    void CuriousTabFunction(float, int = 10.00, char = 'Z');
    void CuriousTabFunction(char, char, char);
};
int main()
{
    CuriousTab objCuriousTab;
    objCuriousTab.CuriousTabFunction(10 * 1.0, int(56.0)); 
    return 0;
}
void CuriousTab::CuriousTabFunction(int xx, float yy, char zz)
{
    x = xx + int(yy);
    cout<< "x = " << x << endl;
}
void CuriousTab::CuriousTabFunction(float xx, int yy, char zz)
{
    x = zz + zz;
    y = xx + yy;
    cout<< " x = " << x << endl;
}
void CuriousTab::CuriousTabFunction(char xx, char yy, char zz)
{
    x = xx + yy + zz; 
    y = float(xx * 2); 
    cout<< " x = " << x << endl;
}

#include<iostream.h> 
class CuriousTab
{
    int x; 
    float y; 
    public:
    CuriousTab(int x)
    {
        x = x;
    }
    CuriousTab(int p = 0, int q = 10)
    {
        x = p += 2; 
        y = q * 1.0f;
    }
    void SetValue(int &y, float z)
    {
        x = y;
        y = (int)z;
    }
    void Display(void)
    {
        cout<< x;
    }
};
int main()
{
    int val = 12; 
    CuriousTab objCuriousTab(val); 
    CuriousTab objTmp();
    objCuriousTab.SetValue(val, 3.14f); 
    objCuriousTab.Display(); 
    return 0; 
}

#include<iostream.h>
#include<string.h> 
class CuriousTabString
{
    char x[50]; 
    char y[50]; 
    char z[50]; 
    public:
    CuriousTabString()
    { }
    CuriousTabString(char* xx)
    {
        strcpy(x, xx); 
        strcpy(y, xx);
    }
    CuriousTabString(char *xx, char *yy = " C++", char *zz = " Programming!")
    {
        strcpy(z, xx); 
        strcat(z, yy); 
        strcat(z, zz);
    } 
    void Display(void)
    {
    cout<< z << endl;
    } 
}; 
int main()
{
    CuriousTabString objStr("Learn", " Java");
    objStr.Display();
    return 0; 
}

#include<iostream.h> 
class CuriousTab
{ 
    public:
    void CuriousTab(int x = 15)
    {
        x = x/2; 
        if(x > 0)
            CuriousTab(); 
        else
            cout<< x % 2; 
    } 
};
int main()
{
    CuriousTab objIB;
    objIB.CuriousTab();
    return 0; 
}

#include<iostream.h> 
static double gDouble; 
static float  gFloat; 
static double gChar; 
static double gSum = 0; 
class BaseOne
{
    public:
    void Display(double x = 0.0, float y = 0.0, char z = 'A')
    {
        gDouble = x;
        gFloat  = y;
        gChar   = int(z);
        gSum    = gDouble + gFloat + gChar;
        cout << gSum; 
    }
};
class BaseTwo
{
    public: 
    void Display(int x = 1, float y = 0.0, char z = 'A')
    {
        gDouble = x;
        gFloat  = y;
        gChar   = int(z); 
        gSum    = gDouble + gFloat + gChar;
        cout << gSum;
    }
};
class Derived : public BaseOne, BaseTwo
{
    void Show()
    {
        cout << gSum;
    } 
}; 
int main()
{
    Derived objDev;
    objDev.BaseTwo::Display(10, 20, 'Z');
    return 0; 
}