C++沉思录学习笔记

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)

尝试

1. 问题在于：如何处理 原对象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时进行复制，即该对象被该句柄唯一绑定时。
承接上节代码：

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，知识建议，随时可灵活改变，但要清楚为什么这样做！对结果负责！