面向对象程序设计1.2 类之间的组合关系

一、复习一下

在1.1里我们定义了类Date，忘记的小伙伴可以看看下面的代码

class Date
{
private:
    int year;
    int month;
    int day;
    //数据成员，默认为私有

public:
    Date():year(2000),month(1),day(1){}//不带参数的构造函数

    Date(int year,int month,int day)//带参数的构造函数
    {
        this->year=year;
        this->month=month;
        this->day=day;
    }

    /*这里可以缺省参数
    Date(int year=2000,int month=1,int day=1)//带参数的构造函数
    {
        this->year=year;
        this->month=month;
        this->day=day;
    }*/

    Date(const Date&t)  //拷贝构造函数，浅拷贝，系统默认会有
    {
        year=t.year;
        month=t.month;
        day=t.day;
    }
    /*  
        Date data1=（2004，6，5）
        Data data2；
        data2=data1；（错误）
        Data data2=data1；（正确）
        等号需要运算符重载才可以使用。
    */

    ~Date() //析构函数
    {
        cout<<"Distract"<<endl;     //当调用析构函数的时候会输出distract。
    }
    void print()    //普通成员函数
    {
        cout<<year<<"\t"<<month<<"\t"<<day<<endl;
    }

};

二、新内容

同样的，我们定义一个Person类

class Person
{
    string name;
    int age;
    char gender;
    Date date;
    static int count;
public:
    Person(){count++;}
    Person(string name,int age,char gender,int y,int m,int d):date(y,m,d)
    {
        this->name=name;
        this->age=age;
        this->gender=gender;
        count++;
    }
    ~Person(){count--;}
    void print()
    {
        cout<<name<<"\t"<<age<<"\t"<<gender<<"\t"<<endl;
        date.print();
        cout<<count<<endl;
    }

};

int Person::count =0;

在数据成员里，我们发现多了两个东西，一个是Date date，一个是 static

类的组合

Date类是我们上面声明定义过的，所以我们这里可以定义一个Date类的对象

在构造函数里对date对象和私有对象进行初始化

静态成员变量

然后是static，静态成员变量，可以看作一个小范围的全局变量，

然后我们去main函数里：

int main()
{
    Person p("Pig",1,'M',2001,1,1);
    Person d,e,f; 
    p.print();
    return 0;
}

这里可以看到我们创建了4个Person类的对象p、d、e、f，并对p进行了初始化。

所以这里每创建一个对象的时候，count都会在原有的基础上+1，会得到如下输出结果

、

其中第三行的那个4，就是 count的值（看Person类里的print）

再比如说，我们new一个对象，现在的main函数如下：

int main（）
{
   Person d("QAQ",1,'F',2000,12,12),e,f;
    Person *p=new Person("Pig",1,'M',2001,1,1);
    p->print();
    delete p;
    d.print();
    return 0;
    
}

输出结果如下：

注意看第三行count值为4，倒数第四行count值为3，这就是delete的时候count--的结果。

注意看上面Person的代码，count的值为私有成员，为了访问count，我们可以用静态成员函数，比如我们可以在下面Public的地方加：

static void printCount()
{
    cout<<count<<endl;
}

这个时候我们就可以通过类名去访问count

int main()
{
    Person d("QAQ",1,'F',2000,12,12),e,f;
    Person *p=new Person("Pig",1,'M',2001,1,1);
    Person::printCount();
    delete p;
    Person::printCount();
    return 0;
}

就会得到如下结果：

友元函数

假设，我们定义了一个整型变量，并初始化 int a=10；

我们想输出a，直接cout<<a；就行了

如果这个时候我们又定义了一个Person x；

我们想像上面一样用cout<<x的形式来输出x的姓名、年龄、性别……

这个时候是不是就要运算符重载一下下（看不懂去看后面的文章）

ostream &operator<<(ostream &q,const Person &p)
{
    cout<<p.name<<"\t"<<p.age<<"\t"<<p.gender<<endl;
    p.date.print();
}

然后这个时候点击运行的手有点抖，感觉哪里不对

然后低头看看就发现了下面这样的报错

然后，恍然大悟！这些是私有成员，不能访问。

这个时候，友元函数就可以出来发光发热。

我们把上面这个函数在Person里friend一下下

friend ostream &operator<<(ostream &q,const Person &p);

意思就是说，上面写的这个函数，是Person的朋友。好朋友要倾囊相助。

于是，这个函数就可以访问到了Person里的私有成员。

我们改一些main函数，然后来运行一下：

//main
int main()
{
    const Person p("Pig",1,'M',2001,1,1);
    cout<<p<<endl;
    return 0;
}

三、写点啥练练手

定义一个类Point

私有成员：x，y

构造函数：有参数，给数据成员赋初值（0，0）

成员函数自己写

定义一个矩形类Rectangle，

私有成员：Point p1,p2,p3,p4用来表示矩形的四个顶点

构造函数：有参数，给数据成员赋初值

printArea()函数返回矩形面积。

printHeight()函数返回矩形的高

printWidth()函数返回矩形的宽。