- 类的组合
- 代码示例
一、类的组合
1. 类组合: 类中的成员数据是另一个类的对象或者是另一个类的指针或引用。通过类的组合可以在已有的抽象的基础上实现更复杂的抽象。
2. 原则: 不仅负责对本类中的基本类型成员数据赋初值,也要对内嵌对象成员初始化。
3. 声明形式:
可以是含参构造函数,也可以复制构造函数
类名::类名(形参):内嵌对象1(参数),内嵌对象2(参数),... { }
4. 构造函数的调用:
- 先调用内嵌对象的构造函数(按内嵌时的声明顺序,先声明者先构造),然后再调用本类的构造函数(析构函数的调用顺序相反)
- 若调用默认构造函数(即没有形参的),则内嵌对象的初始化也将调用相应的默认构造函数。
二、代码示例
例1. 【两点间距离】实现计算两个点(Point)之间的距离(Distance),Distance类的数据成员有Point类的对象。
这里插入代码片
#include<iostream>
using namespace std;
class Point {
int x, y;
public:
Point(int xx, int yy);
Point(Point &p);
~Point() { cout << "Point's destructor is called" << endl; }
int getX() { return x; }
int getY() { return y; }
};
Point::Point(int xx, int yy) {
x = xx;y = yy;
cout << "Point's constructor is called" << endl;
}
Point::Point(Point &p) {
x = p.x;y = p.y;
cout << "Point's copy constructor is called" << endl;
}
class Distance {
private:
Point p1, p2; // Point类的对象作为Distance类的成员数据,声明顺序先p1后p2
d ouble dist;
public:
//Distance(Point a, Point b);
Distance(Point &a, Point &b);
Distance(Distance &d);
double getDis() { return dist; }
~Distance() {cout << "Distance's destrutor was called" << endl;}
};
//Distance::Distance(Point a, Point b) :p1(a), p2(b) { //Point复制构造函数被调用四次
Distance::Distance(Point &a, Point &b) :p1(a), p2(b) { //Point复制构造函数被调用二次,传引用就是给变量起别名
double x = double(p1.getX() - p2.getX());
double y = double(p1.getY() - p2.getY());
dist = sqrt(x * x + y * y);
c out << "Distance's constructor was called" << endl;
}
Distance::Distance(Distance &d) :p1(d.p1), p2(d.p2) {
dist = d.dist;
cout << "Distance's copy constructor was called" << endl;
}
int main() {
Point myp1(1, 2), myp2(3, 5);
Distance myd(myp1, myp2);
cout << "The distance is: " << myd.getDis() << endl;
cout << "==============================" << endl;
Distance myd2(myd);
cout << "The distance is: " << myd2.getDis() << endl;
return 0;
}
在创建myd对象时,首先跑到Distance的含参构造函数处不进去,依次调用内嵌对象myp1、myp2的构造函数,由于形参是传引用(给变量起别名,myp1和a是同一个,只需一次复制构造)并且是p1(a)(即本类对象给新对象初始化),所以调用2次Point类复制构造,然后调用Distance构造函数。myd2的分析也是类似,首先跑到Distance的复制构造处不进去,调用2次Point类复制构造,然后调用Distance复制构造函数。
另外读者可以思考一下上述Distance含参构造形参不传引用,即换为注释代码会出现什么不同。
例2.【点线三角形的类组合】Point类,Line类(含有两个Point类对象),Triangle类(含有三个Line类对象),设计Triangle类的成员函数完成三条边是否能构成三角形的检验和三角形面积计算,面积显示。
#include <iostream>
#include <cstring>
using namespace std;
class Point {
public:
float x, y;
static int i;//静态数据成员,对象共有,用来计点的个数,类内声明
Point() {
cout << "请输入第" << i << "个点的横纵坐标:";
cin >> x >> y;
cout << "(" << x << ", " << y << ")" << endl;
i++;
}
Point(float xx, float yy) {
x = xx;y = yy;
}
Point(Point &p) {
x = p.x; y = p.y;
}
~Point() {}
};
int Point::i = 1;//类外定义并初始化
class Line
{
public:
float l = 0;//边长
static int j;
Point p1, p2;
Line(Point &a, Point &b) :p1(a), p2(b) {
l = sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
cout << "第" << j << "条边的边长为:" << l << endl;
j++;
};
Line(Line &ll) :p1(ll.p1), p2(ll.p2) {
l = ll.l;
}
~Line() {}
};
int Line::j = 1;
class Triangle {
float area;
public:
static bool flag;
Triangle(Line l1, Line l2, Line l3)//构造函数,判断能否构成三角形,Line类对象作为形参调用Line的复制构造函数
{
float a, b, c;
a = l1.l;b = l2.l;c = l3.l;
if (a + b > c&&a + c > b&&b + c > a){
flag = true;
cout << "可以构成三角形" << endl;
float p = (a + b + c) / 2;
area = sqrt(p*(p - a)*(p - b)*(p - c));
}
else {
flag = false;
cout << "不能构成三角形" << endl;
}
}
void show() {
if (flag == true)
{cout << "三角形的面积是:" << area << endl;}
else if (flag == false) {}
};
};
bool Triangle::flag = false;
int main(){
Point p1, p2, p3, p4, p5, p6;//点对象
Line l1(p1, p2), l2(p3, p4), l3(p5, p6);//边对象
Triangle t(l1, l2, l3);//三角形对象
t.show();
return 0;
}
例3.【点三角形的类组合】 Triangle类含有Point类三个对象,含有获取三角形周长和面积的方法。输入三个点坐标,输出三角形周长和面积。
#include<iostream>
#include<cstring>
using namespace std;
class Point {
public:
Point(float x = 0, float y = 0) :x(x), y(y) {}
Point(Point & p);
~Point() { };
float GetX() { return x; }
float GetY() { return y; }
void SetX(float Newx) { x = Newx; }
void SetY(float Newy) { y = Newy; }
float dis(Point B);
private:
float x, y;
};
Point::Point(Point & p) {
x = p.x; y = p.y;
}
float Point::dis(Point B) {
float xx = pow((B.x - x), 2);
float yy = pow((B.y - y), 2);
return sqrt(xx + yy)
}
class Triangel {
public:
Triangel() {};
Triangel(Point newp1, Point newp2, Point newp3) :p1(newp1), p2(newp2), p3(newp3) {}
Triangel(Triangel & p);
~Triangel() {};
Point getPoint1() { return p1; } //获取点的接口
Point getPoint2() { return p2; }
Point getPoint3() { return p3; }
void setPoint1(Point point1) { p1 = point1; } //设置点的接口
void setPoint2(Point point2) { p2 = point2; }
void setPoint3(Point point3) { p3 = point3; }
float getArea();
float getPeri();
private:
float edge1, edge2, edge3, peri, area;
Point p1, p2, p3;
};
Triangel::Triangel(Triangel & p) {
p1 = p.p1;
p2 = p.p2;
p3 = p.p3;
}
float Triangel::getPeri() {
edge1 = getPoint1().dis(p2);//点p1到p2的距离
edge2 = getPoint2().dis(p3);
edge3 = getPoint3().dis(p1);
return peri = edge1 + edge2 + edge3;
}
float Triangel::getArea() {
float half = getPeri() / 2;
return area = sqrt(half*(half - edge1)*(half - edge2)*(half - edge3));
}
int main() {
Point p1(0, 0), p2(0, 3), p3(4, 0);
Triangel tri(p1, p2, p3);
cout << "三角形周长为:" << tri.getPeri() << ", 面积为:" << tri.getArea() << endl;
Point p4(2, 0);
tri.setPoint1(p4);
cout << "三角形周长为:" << tri.getPeri() << ", 面积为:" << tri.getArea() << endl;
}
附:前向引用声明
在提供一个完整的类声明之前,不能声明该类的对象,即下面的例子是错的:
class B;
class A{
public:
B b;
};
class B{
public:
A a;
};
使用前向引用声明时只能使用被声明的符号,而不能涉及类内的任何细节。下面的例子是对的:
class B;
class A{
public:
B &b;
};
class B{
public:
A *a;
};
总结: 类的组合是类中的成员数据是另一个类的对象或者是另一个类的指针或引用。在声明时注意内嵌对象要在参数列表里初始化。代码实现重在逻辑谁用谁的对象,复制构造和含参构造的调用情况,读取和设置私有数据可以写个函数作为借口,注意含参构造函数的形参里是对象还是对象引用。
欢迎关注微信公众号:学编程的金融客,作者:小笨聪