c++面向对象程序设计总结（类的使用）

#include<iostream>
using namespace std;
template <typename t>//t为虚拟类型的名字，自己起的
t maxx(t a,t b,t c)
{
    return max(a,max(b,c));
} 

int main()
{
    double a=1.1,b=2.2,c=3.3;//不管为double 还是int都可以调用maxx 
    cout<<maxx(a,b,c)<<endl;
    int a1=1,b1=2,c1=3;
    cout<<maxx(a1,b1,c1)<<endl;
 } 

void f1(float a,int b=0,int c,char d='a');//错误，
void f2(float a,int c,int b=0,char d='a');//正确 

using namespace std;
class box{
    public:
        box(int ,int ,int );//构造函数 （有无默认参数都行）
        int volume();
    private:
        int h;
        int w;
        int l;
};
box::box(int a,int b,int c)
{
    h=a,w=b,l=c;
}
//其实一般这样写
// box::box(int a,int b,int c):h(a),w(b),l(c){}
//注意如果是数组的话  则要写在大括号内
//box::box(int a,int b,int c,char nam[]):h(a),w(b),l(c)
//{strcpy(name,nam);}

box a[3]={
    box(10,20,30);
    box(20,30,40);
    box(1,2,3);
}

void (* p)();//p是一个指向void型函数的指针 
p=fun;//fun函数入口地址付给p 注意没有括号
(*p)();

time t;
 void (time:: *p)();
 p = &time::gettime();
 (t.*p)();

int box::volume()
 {return (h*l*w);}//实际为{ return this->h * this->l * this->w;}

temple<class t>//t 为虚拟变量名字 可以有多个，但都要加class 如：temple<class t1,class t2> 
class compare{
public:
compare(t a,t b)
{
x=a,y=b;
}
t max() {
return max(a,b);
}
private:
t x,y;
}; 

class yuan{
    public:
        yuan(double a,double b):x(a),y(b){};
        yuan operator +(yuan &t)
        {
            return yuan(x+t.x, y+t.y);
        }
    private:
        double x,y;
};             

class yuan{
    public:
        yuan(double a,double b):x(a),y(b){};
        friend yuan operator +(yuan &t1,yuan &t2)//这个其实挺灵活的，可以自行改变 
        {
            return yuan(t1.x+t2.x, t1.y+t2.y);
        }
    private:
        double x,y;
};             

#include<iostream>
using namespace std;
class Student{
    public:
        void display();
        Student(int n,string nam):num(n),name(nam){}
    protected:
        int num;
        string name;
};
class Student1: public Student{
    public:
        Student1(int n,string nam,int n1,string nam1,int a,string ad):
            Student(n,nam),monitor(n1,nam1),age(a),addr(ad){}//注意初始化，一般用初始化表来 ，同样的，在多级派生中也是如此来构造
        void show()
        {
            monitor.display();
        }
    protected:
        Student monitor;//派生类中的子对象 
        int age;
        string addr;
};
int main()
{
    
 } 

class A
{
    A(int i){}
    .....
};
class B: virtual public A
{
    B(int n):A(n){}
    ...
};
class C: virtual public A
{
    C(int n):C(n){}
    ...
};
class D:public B,public C
{
    D(int n):A(n),B(n),C(n){}//这个必须由最后的派生类中对直接基类和虚基类初始化
}

Student stu(...);
Graduate grad(...);//假设grad是stu的派生，且两者都有display函数
Student *p = &stu;
p->display();
p = &grad;//想通过变换指针指向来，但单单的这样做是不行的，因为这样做会把grad类型强制转化成student的类型 
p->display();

class Point{
    public:
        point();
        ~point();
}; 
class Circle: public Point
{
    public:
        Circle();
        ~Circle();
}
int main()
{
    Point *p = new Circle;
    delete p;
    return 0;
}

class Shape{
    public:
        virtual float area() const {return 0.0;}//虚函数
        virtual float volume() const {return 0.0;}//虚函数
        virtual void shapeName() const = 0; // 纯虚函数 形式为 virtual 函数类型 函数名字 (参数列表) =0;
};

#include<iostream>
using namespace std;
class Shape
{
    public:
        virtual float area() const {return 0.00;}
        virtual float volume() const {return 0.00;}
        virtual void ShapeName() const = 0;
};
class Point: public Shape
{
    public:
        Point(float a=0,float b=0): x(a), y(b){};
        void SetPoint(float a,float b)
        {
            x=a,y=b;
        }
        float getX() const {return x;}
        float getY() const {return y;}
        
        virtual void ShapeName() const {cout<<"point"<<endl;}
        friend ostream &operator <<(ostream &,const Point &);
    protected:
        float x,y;
};
ostream &operator <<(ostream &output,const Point &p)
{
        output<<"["<<p.x<<","<<p.y<<"]"<<endl;
        return output;
}
class Circle: public Point
{
    public:
        Circle(float x=0,float y=0,float r=0):Point(x,y),radius(r) {}
        
        void SetRaidus(float r){ radius = r;}
        
        float GetRadius() const {return radius;}
        
        virtual float area() const{ return 3.14 * radius * radius;}
        
        virtual void ShapeName() const {cout<<"Circle"<<endl;}
        
        friend ostream &operator <<(ostream &,const Circle &);
        protected:
            float radius;
};
ostream &operator <<(ostream &out,const Circle &c)
{
    out<<"["<<c.x<<" "<<c.y<<"]"<<endl;
    out<<"r="<<c.radius<<endl;
    return out;
}
class Yuan: public Circle
{
    public:
        Yuan(float x=0,float y=0,float r=0,float h=0):Circle(x,y,r),height(h){}
        
        void SetHeight(float h) {height = h;}
        
        virtual float area() const {return 2 * Circle::area() + 2 * 3.14 * radius * height;}
        
        virtual float vulume() const {return Circle::area() * height;}
        
        virtual void ShapeName() const {cout<<"Yuan"<<endl;}
        
        friend ostream &operator <<(ostream &,const Yuan &);
    protected:
        float height;
};
ostream & operator <<(ostream &out,const Yuan &Y)
{
    out<<"["<<Y.x<<" "<<Y.y<<"],r="<<Y.radius<<"H="<<Y.height<<endl;
    return out;
}

int main()
{
    Point point (3.2,4.5);
    Circle circle(2.4,1.2,5.6);
    Yuan yuan(3.4,6.4,5.2,10.5);
    point.ShapeName();
    cout<<point<<endl;
    
    circle.ShapeName();
    cout<<circle<<endl;
    
    yuan.ShapeName();
    cout<<yuan<<endl;
    
    Shape *pt;
    pt=&point;
    pt->ShapeName();
    
    pt=&circle;
    pt->ShapeName();
    pt=&yuan;
    pt->ShapeName();
    return 0;
}