0,C++、抽象 —— 利用类实现功能 + 存储状态信息
1,支持C的地方往往支持C++。
2,抽象,接口,模块,独立。
3,可靠性与速度
4,哲学:“只为用到的东西付出代价”
不会被继承的类往往不需要虚析构函数,只会增加运行代价
类设计者的核查表
1,需要构造函数吗?
2,成员是私有的吗?
3,需要无参构造函数吗?
4,每个构造函数是否都初始化了所有数据成员
5,需要析构吗?
6,类需要虚析构函数吗?
—— 哲学:“只为用到的东西付出代价”
不会被继承的类往往不需要虚析构函数,只会增加运行代价
7,需要复制构造吗? & 需要赋值操作符吗?
—— 一般要么都需要 or 都不需要
8,你的赋值操作符能正确将自己赋值给自己吗?
—— 两种方法:1,先判断是否是自己;2,将旧目标值保存起来,直到将源值复制完成。
9,需要关系操作符吗?
10,删除数组时记住用 delete[]
了吗
11,函数参数用 const 了吗?
12,函数是 const 函数 吗?
13,引用参数是否是const?
代理类
代理(surrogate):设计一种C++容器,包含不同类型的对象。
首先,明确使用一个共同基类作为数组基本类型是行不通的!
1,该共同基类具备共同特征,但应该是抽象基类,拥有纯虚函数,无法被实例化!
2,如果出现对数组某项赋值的情况,会丢失源对象的其他信息而只保留基类的信息。
经典解决方案
设计一个间接层,比如数组存储指针而不是对象。
—— 新的问题:如何保证指针所指向内存有效?比如给容器存入了一个本地变量,而容器本身是个生存期更长的对象。
↓
解决办法:存储指向副本的指针
—— 新的问题:
1,难以管理内存;
2,想让数组一个元素复制另一个元素的值时,已经无法确定其真正类型了。(数组元素丢失了类型信息,尽管它可以被正确读取)
↓
解决办法:虚复制函数
抽象基类添加虚复制函数copy,返回指向基类类型的指针。使得各自类型返回自己类型的副本的指针。但要注意内存管理,同时也应该添加虚析构函数,释放内存!
代理类
解决问题的关键在于用类来表示概念,也是最基本的C++设计原则。
代理类包含一个抽象基类的指针数据成员,与该类派生类绑定。声明并定义有空构造,构造,析构,复制构造,赋值符重载等函数。
举例:
停车场(数组),车(Vehicle,抽象基类),其他车(派生类)。
VehicleSurrogate 代理类。
注意:代理类要加上抽象基类的接口!
#include <iostream>
class Vehicle
{
public:
virtual double weight() const = 0;
virtual void start() = 0;
virtual Vehicle *copy() const = 0;
virtual ~Vehicle() {}
//...
};
class RoadVehicle : public Vehicle
{
double weight() const { return 1; }
void start() { std::cout << "RoadVehicle start!" << std::endl; }
/*...*/
};
class AutoVehicle : public RoadVehicle
{
Vehicle *copy() const;
/*...*/
};
Vehicle *AutoVehicle::copy() const
{
return new AutoVehicle(*this);
}
class Aircraft : public Vehicle
{
/*...*/
};
class Helicopter : public Aircraft
{
/*...*/
};
class VehicleSurrogate
{
public:
VehicleSurrogate();
VehicleSurrogate(const Vehicle &);
~VehicleSurrogate();
VehicleSurrogate(const VehicleSurrogate &);
VehicleSurrogate &operator=(const VehicleSurrogate &);
//来自 Vehicle 的接口
double weight() const;
void start();
private:
Vehicle *vp;
};
VehicleSurrogate::VehicleSurrogate() : vp(nullptr) {}
VehicleSurrogate::VehicleSurrogate(const Vehicle &v) : vp(v.copy()) {}
VehicleSurrogate::~VehicleSurrogate()
{
delete vp;
}
VehicleSurrogate::VehicleSurrogate(const VehicleSurrogate &v) : vp(v.vp ? v.vp->copy() : nullptr) {}
VehicleSurrogate &VehicleSurrogate::operator=(const VehicleSurrogate &v)
{
if (this != &v)
{
delete vp;
vp = (v.vp ? v.vp->copy() : nullptr);
}
return *this;
}
double VehicleSurrogate::weight() const
{
if (vp == nullptr)
throw "empty VehicleSurrogate.weight()";
return vp->weight();
}
void VehicleSurrogate::start()
{
if (vp == nullptr)
throw "empty VehicleSurrogate.weight()";
return vp->start();
}
int main(int argc, char *argv[])
{
VehicleSurrogate parking_lot[100];
AutoVehicle x;
int num_vehicles = 2;
parking_lot[num_vehicles] = x;
parking_lot[num_vehicles].start();
int w = parking_lot[num_vehicles].weight();
std::cout << "weight: " << w << std::endl;
return 0;
}
句柄
为了避免复制操作而改进代理类。
注意!C++有时中不可直接复制指针!
handle 是一种多态操作,与代理类功能类似,但是要避免对象复制所带来的浪费。有时也叫做“智能指针”。
一个简单的类
- 没有指针成员的类往往可以使用默认的复制构造函数和赋值操作符。
- 注意!无参构造函数一定要注意单独写出来!如果使用缺省参数则一定要主要特殊情况的参数输入是否符合逻辑!
Point类
class Point{
public:
Point(): xval(0),yval(0) {}
Point(int x,int y): xval(x),yval(y) {}
int x() const {return xval;}
int y() const {return yval;}
Point& x(int xv) {xval = xv; return *this;}
Point& y(int yv) {yval = yv; return *this;}
Private:
int xval,yval;
};
- 注意:不能用缺省参数函数来解决无参构造函数的问题 —— 只输入一个参数的构造函数毫无意义,是错误的。
- 返回自身引用的骚操作(可以进行连续操作):
p.x(42).y(42)
尝试
-
问题在于:如何处理 原对象Point 与 句柄类的关系 —— 在 原Point对象被销毁之后,句柄类应该怎么知道这一消息并如何对自身进行处理。
handle 应该创建和销毁被绑定的对象
2.是否可以用->
操作符返回对象指针以获取对象?不可,这样直接转发操作,无法禁止一些操作或改写一些操作。
简单实现
明确:
- 绕开
->
直接转发对象的操作,则需要指明 handle需要提供的操作。 - 适当的构造与析构函数
- 适当的复制,赋值操作符。
class Handle{
public:
Handle();
Handle(int x,int y);
Handle(const Handle& h);
Handle(const Point& p);
Handle &operator=(const Handle& h);
~ Handle();
int x() const;
int y() const;
Handle& x(int);
Handle& y(int);
private:
//...
};
引用计数型句柄
不复制内存意味着可能会有多个句柄绑定于同一个对象,因此,我们需要确定有多少个句柄绑定在同一个对象上,这样才能知道何时删除对象。那么,从何处何时进行这种绑定计数呢?
在Point类中计数?不行,我们不应该改变已经存在的对象类。
在Handle类中计数?不行,无法得知其他绑定该对象的句柄,不易实现。
=> 定义一个新类!这种类纯粹为实现而定义,因而其成员都应该是 private的,只有Handle可以访问,所以计数类应该设Handle为友元。设该类为UPoint
,它是 Point 与 Handle 的桥梁,应该设计好 Point相对于Handle的所有接口。
class UPoint{
friend class Handle;
Point p;
int u;
UPoint():u(1) {}
UPoint(int vx,int vy):p(vx,vy),u(1) {}
UPoint(const Point& vp):p(vp),u(1) {}
};
class Handle{
public:
Handle():up(new UPoint()) {}
Handle(int x,int y):up(new UPoint(x,y)) {}
Handle(const Handle& h):up(h.up) {++up->u;}
Handle(const Point& p):up(new UPoint(p)){}
Handle &operator=(const Handle& h);
~Handle();
int x() const {return up->p.x();}
int y() const {return up->p.y();}
Handle& x(int);
Handle& y(int);
private:
//...
UPoint *up;
};
Handle::~Handle(){
if(--up->u == 0)
delete up;
}
Handle &Handle::operator=(const Handle& h)
{
++h.up->u;
if(--up->u == 0)
delete up;
up = h.up;
return *this;
}
写时复制
两种语义:
- 指针语义:多个句柄指向同一个对象,且任意句柄都会改变这个对象。
- 值语义:多个句柄指向同一个对象,但通过句柄并不会真正改变这个对象,而是生成了一个副本。利用写时复制技术,可以减少全部复制的损耗又有了全部复制的效果。
实现写时复制,要注意的是应该在 引用计数不等于1时进行复制,即该对象被该句柄唯一绑定时。
承接上节代码:文章来源:https://www.toymoban.com/news/detail-475475.html
Handle& Handle::x(int vx)
{
if (up->u != 1)
{
--up->u;
up = new UPoint(up->p);
}
up->p.x(vx);
return *this;
}
Handle& Handle::y(int vy)
{
if (up->u != 1)
{
--up->u;
up = new UPoint(up->p);
}
up->p.y(vy);
return *this;
}
如何学习 C++
1,找当地专家
2,选择一种工具包并适应它
3,C的某些部分必须,其他地方又不是必须…
—— C++不确定类的内存存储结构
4,如果只使用完全理解的知识,就要想办法扩展理解范围 —— 用已知方法解决新问题
5,选择新特性,用新特性解决这个问题。理解 程序在做什么,为什么
—— 即,逐步加深,扩展理解
6,如果第一个程序不成熟,不妨再写一个
7,从C到C++,停止考虑程序结构,开始考虑程序数据的行为。
8,早些考虑测试,分模块测试
9,知识建议,随时可灵活改变,但要清楚为什么这样做!对结果负责!文章来源地址https://www.toymoban.com/news/detail-475475.html
到了这里,关于C++沉思录学习笔记的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!