C++ function templates 1

#include <iostream>

using namespace std;
template <class A>
A dodaj(A a,A b)
{
    return a+b;
}
int main()
{
    cout << "function templates!" << endl;
    cout<<"int="<<dodaj(1,2)<<endl;
    cout<<"float="<<dodaj(1.01,2.11)<<endl;
    cout<<"char="<<dodaj(' ','b')<<endl;
    return 0;
}

C++ Constructor & Descrutor

_____________________________________________
#include <iostream>

using namespace std;
class A
{
    public:
        A()
        {
            cout << "Constructor A" << endl;
        }
        ~A()
        {
            cout << "Destructor A" << endl;
        }
private:
    int x;
};
class B:public A
{
public:
    B():A()
    {
        cout << "Constructor B" << endl;
    }
    ~B()
    {
        cout << "Destructor B" << endl;
    }
};

int main()
{
    B o1;
    return 0;
}

C++ virtual inheritance /c++ dziedziczenie virtualne

:)
________________________________________________
#include <iostream>
using namespace std;
class A
{
public:
     void read()
    {
    cout << "This is A" << endl;
    }
private:

};
class B:virtual public A
{
public:

private:

};
class C:virtual public A
{
public:

private:

};
class D:public B,public C
{

};
int main()
{

D o1;
o1.read();
return 0;
}

C++ visual function / C++ visualna funkcja

This is visual function
__________________________________________________________
#include <iostream>
using namespace std;
class A
{
public:
    virtual void read()
    {
    cout << "This is A" << endl;
    }
private:

};
class B:public A
{
public:
     void read()
    {
    cout << "This is B" << endl;
    }
private:

};
class C:public A
{
public:
     void read()
    {
    cout << "This is C" << endl;
    }
private:
};

int main()
{
//standard use
A o1;
o1.read();
B o2;
o2.read();
C o3;
o3.read();
//Vitualization
cout << "Virtual" << endl;
A *wsk=&o1;
wsk->read();
wsk=&o2;
wsk->read();
wsk=&o3;
wsk->read();
return 0;
}

C++ inheritance basics / C++ dziedziczenie podstawy

Start inheritances
_________________________________________________________________
#include <iostream>
using namespace std;
class A
{
public:
    A(int X,int Y):x(X),y(Y){}
    A operator =(const A &wzor);
    void write();
protected:
private:
    int x,y;
};
void A::write()
{
    cout <<"Data"<<endl<< "x=" <<x<<endl<<"y="<<y<< endl;
}
A A::operator =(const A &wzor)
{
    x=wzor.x;
    y=wzor.y;
    return *this;
}
/*-----------------------------------------------------------------------------*/
class B:public A
{
public:
    B(int X, int Y, int Z):A(X,Y),z(Z){}
    B operator =(const B &wzor);
    void write();
protected:
private:
    int z;

};
void B::write()
{
    A::write();
    cout << "z=" <<z<<endl;
}
B B::operator =(const B &wzor)
{
    (*this).A::operator=(wzor);
    z=wzor.z;
    return *this;
}

int main()
{
    A o1(1,2);
    o1.write();
    B o2(12,44,66);
    o2.write();
    B o3=o2;
    o3.write();
    return 0;
}