c++学习（四）

公用继承：

公用基类的成员                                    在公用派生类中的访问属性

私有成员                                          不可访问

公用成员                                          公用

保护成员                                          保护

 

私有继承：

私有基类中的成员                                  在私有派生类中的访问属性

私有成员                                          不可访问

公用成员                                          私有

保护成员                                          私有

 

保护成员和保护继承：

基类中的成员    在公用派生类中的访问属性   在私有派生类中的访问属性  在保护派生类中的访问属性

私有成员        不可访问                   不可访问                  不可访问

公用成员        公用                        私有                      保护

保护成员        保护                        私有                      保护

 

派生类中的成员的访问属性：

派生类中的成员                   在派生中           在派生类外部          在下层公用派生类中

派生类中访问属性为公用的成员     可以               可以                  可以

派生类访问属性为受保护的成员     可以               不可以                可以

派生类访问属性为私有成员         不可以             不可以                 不可以

在派生类中不可以访问的成员       不可以             不可以                 不可以

#include<iostream>
#include<string>
using namespace std;
class Stud{
    public:
        Stud(){num=12;name="logo";***='M';}
        void disp();
    protected:
        int num;
        string name;
        char ***;
};
void Stud::disp()
{
cout<<"num:"<<num<<endl;
cout<<"name:"<<name<<endl;
cout<<"***:"<<***<<endl;
}

class Std1:protected Stud
{
    public:
        Std1(){age=40;addr="longpengcheng";}
        void disp1();
    private:
        int age;
        string addr;
};

void Std1::disp1()
{
cout<<"num:"<<num<<endl;
cout<<"name:"<<name<<endl;
cout<<"***:"<<***<<endl;
cout<<"age:"<<age<<endl;
cout<<"address:"<<addr<<endl;
}

int main()
{
Std1 s;
s.disp1();
return 0;
}

基类的构造函数和析构函数是不能继承的。继承过来的基类的成员初始化工作也要由派生类的构造函数承担，在执行派生类的构造函数时，调用基类的构造函数。

一般形式： 派生类构造函数名（总参数列表）：基类构造函数名（参数列表）

{派生类中新增加的数据成员初始化语句}

#include<iostream>
#include<string>
using namespace std;
class Student{
    public:
        Student(int n,string nam,char s)
        {
        num=n;
        name=nam;
        ***=s;
                }
        ~Student(){} //基类中到析构函数
    protected:
        int num;
        string name;
        char ***;
};

class Student1:public Student
{
    public:
        Student1(int n,string nam,char s,int a,string ad):Student(n,nam,s){
            age=a;
            addr=ad;
}//等效表达法： Student1(int n,string nam,char s,int a,string ad):Student(n,nam,s)，age(a),addr(ad){}
        void show()
            {cout<<"num:"<<num<<endl;
            cout<<"name:"<<name<<endl;
            cout<<"***:"<<***<<endl;
            cout<<"age:"<<age<<endl;
            cout<<"address:"<<addr<<endl;
                }
        ~Student1(){} //派生类到析构函数
    private:
        int age;
        string addr;
};
int main()
{
Student1 std1(10010,"long",'M',12,"zhongguancun");
Student1 std2(10011,"peng",'W',13,"guangdianyuan");
std1.show();
std2.show();
return 0;
}

在建立一个对象四，执行构造函数的顺利时：首先派生类中的构造函数先调用基类构造函数，在执行派生类的构造函数本身。

在派生类对象释放时，先执行派生类析构函数~Student1()，再执行其基类析构函数~Student().

多重继承引起的二义问题：

#include<iostream>
using namespace std;
class N
{
public:
    int a;
    void display(){cout<<"A:a= "<<a<<endl;}
};

class A:public N
{
public:
int a1;
};

class B:public N
{
public:
     int a2;
};

class C:public A,public B
{
public:
int a3;
void show(){cout<<"a3= "<<a3<<endl;}
};
int main()
{
C c1;
c1.A::a=3;
c1.A::display();
c1.B::a=5;
c1.B::display();
c1.a3=50;
c1.show();
return 0;
}

C c1;

c1.a3=3;

c1.display();

访问的是派生类C中的成员。规则是：基类的同名成员在派生类中被屏蔽，成为不可见的，或者说派生类中的新增加的同名成员覆盖积累中的同名成员。

c1.A::a=3;c1.A::display()；这表示访问的是类N的派生类A中的基类成员。

 

虚基类：c++提供虚基类使得在继承间接共同基类时只保留一份成员。虚基类是在声明派生类时指定继承方式时声明的，因为一个派生类可以再生成一个派生类时作为虚基类，而在生成另一个派生不作为虚基类。

class 派生类名：virtual 继承方式 基类名

虚基类的初始化：在最后的派生类中不仅要负责对其派生类的初始化还要负责对虚基类的初始化。

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
    Person(string nam,char s,int a){name=nam;***=s;age=a;}
protected:
    string name;
    char ***;
    int age;
};

class Teacher:virtual public Person
{
public:
    Teacher(string nam,char s,int a,string t):Person(nam,s,a){title=t;}
protected:
    string title;
};

class Student:virtual public Person
{
public:
    Student(string nam,char s,int a,float sco):Person(nam,s,a){score=sco;}
protected:
    float score;
};

class Graduate:public Teacher,public Student
{
public:
    Graduate(string nam,char s,int a,string t,float sco,float w):Person(nam,s,a),Teacher(nam,s,a,t),Student(nam,s,a,sco){wage=w;}
    void show()
    {cout<<"name:"<<name<<endl;
    cout<<"***:"<<***<<endl;
    cout<<"age:"<<age<<endl;
    cout<<"title:"<<title<<endl;
    cout<<"score:"<<score<<endl;
    cout<<"wage:"<<wage<<endl;
    }
private:
    float wage;
};

int main()
{
Graduate s("lpc",'M',24,"boshi",89,5555);
s.show();
return 0;
}

先建立一个Point（点）类，包含数据成员x，y（坐标点），以它为基类，派生一个Circle（圆）类，再增加数据成员r，再以Circle类为直接基类，派生一个Cylinder（圆柱体）类，再增加数据成员h。要求编写程序，重载运算符“<<”和“>>”

#include<iostream>
using namespace std;
class Point{
    public:
        Point(float x=0,float y=0);
        void setPoint(float,float);
        float getx(){return x;}
        float gety(){return y;}
        friend ostream & operator <<(ostream &,const Point &);
    protected:
        float x;
        float y;
};

Point::Point(float a,float b){x=a;y=b;}
void Point::setPoint(float x1,float y1)
{
x=x1;y=y1;
}

ostream & operator<<(ostream &output,const Point &p)
{ output<<"["<<p.x<<","<<p.y<<"]"<<endl;
    return output;
}

class Circle:public Point
{
    public:
        Circle(float a,float b,float c):Point(a,b),r(c){}
        void setr(float);
        float getr(){return r;}
        float area() const {return (3.14*r*r);}
        friend ostream & operator <<(ostream &,const Circle &);
    protected:
        float r;
};

ostream & operator <<(ostream &output,const Circle &c)
{
output<<"cent:"<<"["<<c.x<<","<<c.y<<"],r="<<c.r<<",area="<<c.area()<<endl;
return output;
}

void Circle::setr(float d)
{r=d;}


class Cylinder:public Circle
{
    public:
        Cylinder(float a,float b,float c,float d):Circle(a,b,c),h(d){}
        void seth(float d){h=d;}
        float geth(){return h;}
        float tiji() const;
        friend ostream & operator <<(ostream &,const Cylinder &);
    private:
        float h;
};

ostream & operator<<(ostream &output,const Cylinder &cy)
{
output<<"cent:"<<"["<<cy.x<<","<<cy.y<<"],r="<<cy.r<<",area="<<cy.area()<<"h="<<cy.h<<"tiji:"<<cy.tiji()<<endl;
}
float Cylinder::tiji() const
{
return Circle::area()*h;
}

int main()
{
Cylinder c1(3.5,6.4,2.5,5.5);
cout<<"cent:"<<"["<<c1.getx()<<","<<c1.gety()<<"],r="<<c1.getr()<<",area="<<c1.area()<<",h="<<c1.geth()<<",tiji="<<c1.tiji()<<endl;
c1.setPoint(1.2,5.6);
c1.setr(6);
c1.seth(8);
cout<<"cent:"<<"["<<c1.getx()<<","<<c1.gety()<<"],r="<<c1.getr()<<",area="<<c1.area()<<",h="<<c1.geth()<<",tiji="<<c1.tiji()<<endl;
return 0;
}