What will be the output of the following program?

#include<iostream.h>
#include<string.h> 
class CuriousTab
{
    char str[50]; 
    char tmp[50]; 
    public:
    CuriousTab(char *s)
    {
        strcpy(str, s);
    }
    int CuriousTabFunction()
    {
        int i = 0, j = 0; 
        while(*(str + i))
        {
            if(*(str + i++) == ' ')
                *(tmp + j++) = *(str + i);
        }
        *(tmp + j) = 0; 
        return strlen(tmp); 
    }
};
int main()
{
    char txt[] = "Welcome to CuriousTab.com!";
    CuriousTab objCuriousTab(txt); 
    cout<< objCuriousTab.CuriousTabFunction();
    return 0;
}

#include<iostream.h> 
class CuriousTab
{
    int x; 
    float y; 
    public:
    void Function()
    {
        x = 4; 
        y = 2.50; delete this;
    }
    void Display()
    {
        cout<< x << " " << y;
    } 
}; 
int main()
{
    CuriousTab *pCuriousTab = new CuriousTab();
    pCuriousTab->Function(); 
    pCuriousTab->Function(); 
    pCuriousTab->Display(); 
    return 0; 
}

#include<iostream.h> 
class CuriousTabTeam
{
    int x, y; 
    public:
    CuriousTabTeam(int xx)
    {
        x = ++xx;
    }
    void Display()
    {
        cout<< --x << " ";
    }
};
int main()
{
    CuriousTabTeam objBT(45);
    objBT.Display();
    int *p = (int*)&objBT;
    *p = 23;
    objBT.Display();
    return 0; 
}

#include<iostream.h> 
class CuriousTabBase
{
    int x, y; 
    public:
    CuriousTabBase(int xx = 10, int yy = 10)
    {
        x = xx;
        y = yy;
    }
    void Show()
    {
        cout<< x * y << endl;
    }
};
class CuriousTabDerived : public CuriousTabBase
{
    private:
        CuriousTabBase objBase; 
    public:
    CuriousTabDerived(int xx, int yy) : CuriousTabBase(xx, yy)
    {
        objBase.Show();
    }
};
int main()
{
    CuriousTabDerived objDev(10, 20);
    return 0; 
}

#include<iostream.h> 
class CuriousTab
{
    static int x; 
    public:
    static void SetData(int xx)
    {
        x = xx; 
    }
    void Display() 
    {
        cout<< x ;
    }
};
int CuriousTab::x = 0; 
int main()
{
    CuriousTab::SetData(33);
    CuriousTab::Display();
    return 0; 
}

#include<iostream.h> 
class CuriousTab
{
    static int count; 
    public:
    static void First(void)
    {
        count = 10;
    }
    static void Second(int x)
    {
        count = count + x; 
    }
    static void Display(void)
    {
        cout<< count << endl;
    } 
};
int CuriousTab::count = 0; 
int main()
{
    CuriousTab :: First();
    CuriousTab :: Second(5);
    CuriousTab :: Display();
    return 0; 
}

#include<iostream.h> 
class CuriousTabBase
{
    int x, y; 
    public:
    CuriousTabBase(int xx = 10, int yy = 10)
    {
        x = xx;
        y = yy;
    }
    void Show()
    {
        cout<< x * y << endl;
    }
};
class CuriousTabDerived : public CuriousTabBase
{
    private:
        CuriousTabBase objBase; 
    public:
    CuriousTabDerived(int xx, int yy) : CuriousTabBase(xx, yy), objBase(yy, yy)
    {
        objBase.Show();
    }
};
int main()
{
    CuriousTabDerived objDev(10, 20);
    return 0; 
}

#include<iostream.h> 
class A
{
    public:
    void CuriousTabFunction(void)
    {
        cout<< "Class A" << endl;
    }
};
class B: public A
{
    public:
    void CuriousTabFunction(void)
    {
        cout<< "Class B" << endl;
    } 
};
class C : public B
{
    public:
    void CuriousTabFunction(void)
    {
        cout<< "Class C" << endl;
    } 
};
int main()
{
    A *ptr;
    B objB;
    ptr = &objB;
    ptr = new C();
    ptr->CuriousTabFunction();
    return 0; 
}

1. A reference is not a constant pointer.
2. A referenced is automatically de-referenced.