第二部分-构造/析构/赋值运算

条款05:编译器可为class创建默认的构造函数、析构函数、拷贝构造函数、拷贝赋值运算符。

条款06:拒绝编译器自动生成的函数做法。

例如不希望使用class的默认拷贝函数和默认拷贝赋值运算符,有两种做法:
1.将函数声明为private。
此时对象无法调用此函数(编译期就报错)。
但是此方法不是绝对安全,因为成员函数和友元函数仍然可以调用,此时连接器会报错。为了将连接期错误转移到编译期(更早侦测出错误),使用方法2.

2.定义uncopyable的base class

class Uncopyable{
protected:
	Uncopyable(){}
	~Uncopyable(){}
private:
	Uncopyable(const Uncopyable&);
	Uncopyable& operator=(const Uncopyable&);
};

class HomeForSale : private Uncopyable{
	...
};

此时,无论任何人尝试拷贝HomeForSale对象,编译器尝试生成拷贝构造函数和拷贝赋值运算符,而这些函数的默认版本会尝试调用base class 的对应版本,此时调用会被编译器拒绝(因为是private的)。

条款07:为多态基类声明virtual析构函数。

当derived class对象由一个base class指针被删除,而该base class带着一个non-virtual析构函数,其结果未定义–通常是该对象的derived成分未被销毁。

当base class带有virtual析构函数时:
描述析构函数与虚函数机制的交互时,最简单的表述是:将所有析构函数都视为具有相同的名字(即使它们并非真的同名)。例如,假定Derived类是Base类的一个派生类,并假定Base类中的析构函数标记为virtual。现在来分析以下代码:

Base *pBase= new Derived;
...
delete pBase;

为Base调用delete时,会调用一个析构函数。由于Base类中的析构函数标记为virtual,而且指向的对象属于Derived类型,所以会调用Derived类中的析构函数。(注:将析构函数标记为virtual后,派生类所有的析构函数都自动成为virtual的(不管是否用virtual来标记它们))根据c++规则,派生类虚析构函数释放派生对象资源后,继续调用父类(虚)析构函数。而假设base class析构函数为non-virtual,则不会进行子类虚析构函数的调用,而是仅仅调用base class的析构函数,子类资源可能未被销毁。

有时候令class带一个pure virtual析构函数非常方便,纯虚函数导致抽象类–不能被实例化,有时候需要抽象类,但未想好纯虚函数,此时可将析构函数声明为纯虚,作为base class:

class AMOV{
public:
	virtual ~AMOV() = 0;
};

这样,它既是一个抽象class,又无需担心析构函数的问题。但需要注意的是,这个纯虚析构函数必须定义:

AMOV::~AMOV() {}

因为子类虚析构函数会调用父类虚析构函数,如果无定义,会报错。

总结:带多态性质的(polymorphic)base class应该声明一个virtual 析构函数。如果base class带有任何virtual函数,应该拥有一个虚析构函数。

条款08:别让异常逃离析构函数。

析构函数绝对不要抛出异常。如果一个被析构函数调用的函数可能抛出异常,析构函数应该捕捉任何异常,然后吞下他们(不传播)或者结束程序。

class DBConnection{
public:
	static DBConnection create();
	void close();
};

class DBConn{
public:
	...
	~DBConn(){
		db.close();
	}
private:
	DBConnection db;
};

我们希望客户(DBConnection)完成操作后正确close(), 创建DBConn并在其析构函数中调用close()。问题是,如果close()导致异常,析构函数会传播异常,这可能会导致不明确的行为。所以应该重新设计析构函数:

DBConn::~DBConn(){
	try{db.close();}
	catch(...){
		制作运转记录,记下对close()的调用失败;
		abort()//可选
	}
}

在析构函数中,选择捕获所有异常,防止传播。记录下失败信息,后有两种选择,一是调用abort()直接强迫结束程序(防止出现不明确行为),二是只吞掉异常,不做其他行为,程序继续执行。

这两种情况下,客户无法对可能出现的问题做出反应。更好的方案是在DBConn中自己设计一个close()接口,供客户调用

class DBConn{
public:
	void close(){
		db.close();
		closed = true;
	}
	
	~DBConn(){
		if(!closed){
			try{db.close();}
			catch(...){
				制作运转记录,记下对close()的调用失败;
				abort()//可选
			}
		}
	}
private:
	DBConnection db;
	bool closed;
};

在db的析构函数中调用close(), 将close()的责任从DBConn转到DBConnection,但DBConn的析构函数仍然内含双保险调用。也就是说,给予客户处理错误的机会,若close()出现错误,客户可以选择处理或者忽略,如果客户忽略此错误,DBConn的析构仍会进行之前的try catch处理这个错误(吞下异常或结束程序)。

条款09:绝不在构造函数和析构函数中调用虚函数。

因为这类调用从不下降至derived class。

条款10、11:关于operator=返回引用以及处理自赋值。

operator=应返回自身对象引用(*this)以处理连续赋值的情况;
operator=函数内应处理自赋值的情况(防止在赋值前释放自身资源):
先使用另一个指针p指向当前对象,再申请内存资源存放参数所指对象。若申请成功,使当前指针指向这块资源,delete p 释放原有资源,返回当前指针指向对象;若申请失败,当前指针所指对象也未改变,安全。

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,下面是一个基于动态数组的矩阵类的实现,包括类的构造析构、拷贝、赋值等基本操作,以及矩阵的按元素加减乘除运算,矩阵的乘法、转置和求逆等运算: ```c++ #include <iostream> #include <vector> using namespace std; class Matrix { private: int row; int col; vector<vector<double>> data; public: // 构造函数 Matrix(int r, int c, double val = 0) { row = r; col = c; data.resize(row, vector<double>(col, val)); } // 拷贝构造函数 Matrix(const Matrix &other) { row = other.row; col = other.col; data = other.data; } // 析构函数 ~Matrix() {} // 赋值运算符 Matrix &operator=(const Matrix &other) { if (this != &other) { row = other.row; col = other.col; data = other.data; } return *this; } // 矩阵按元素加法 Matrix operator+(const Matrix &other) const { if (row != other.row || col != other.col) { throw "矩阵加法维度不匹配!"; } Matrix result(row, col); for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { result.data[i][j] = data[i][j] + other.data[i][j]; } } return result; } // 矩阵按元素减法 Matrix operator-(const Matrix &other) const { if (row != other.row || col != other.col) { throw "矩阵减法维度不匹配!"; } Matrix result(row, col); for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { result.data[i][j] = data[i][j] - other.data[i][j]; } } return result; } // 矩阵按元素乘法 Matrix operator*(const Matrix &other) const { if (row != other.row || col != other.col) { throw "矩阵乘法维度不匹配!"; } Matrix result(row, col); for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { result.data[i][j] = data[i][j] * other.data[i][j]; } } return result; } // 矩阵按元素除法 Matrix operator/(const Matrix &other) const { if (row != other.row || col != other.col) { throw "矩阵除法维度不匹配!"; } Matrix result(row, col); for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { if (other.data[i][j] == 0) { throw "矩阵除法除数不能为0!"; } result.data[i][j] = data[i][j] / other.data[i][j]; } } return result; } // 矩阵乘法 Matrix operator*(const Matrix &other) const { if (col != other.row) { throw "矩阵乘法维度不匹配!"; } Matrix result(row, other.col); for (int i = 0; i < row; i++) { for (int j = 0; j < other.col; j++) { for (int k = 0; k < col; k++) { result.data[i][j] += data[i][k] * other.data[k][j]; } } } return result; } // 矩阵转置 Matrix transpose() const { Matrix result(col, row); for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { result.data[j][i] = data[i][j]; } } return result; } // 矩阵求逆 Matrix inverse() const { if (row != col) { throw "非方阵不可求逆!"; } int n = row; Matrix A(*this); Matrix B(n, n); B.eye(); for (int k = 0; k < n; k++) { double max = abs(A.data[k][k]); int index = k; // 找到最大元素所在的行 for (int i = k + 1; i < n; i++) { if (abs(A.data[i][k]) > max) { max = abs(A.data[i][k]); index = i; } } // 如果最大元素为0,则该矩阵不可逆 if (max == 0) { throw "该矩阵不可逆!"; } // 交换第k行和第index行 if (index != k) { for (int j = 0; j < n; j++) { swap(A.data[k][j], A.data[index][j]); swap(B.data[k][j], B.data[index][j]); } } // 使A[k][k]为1 double d = A.data[k][k]; for (int j = 0; j < n; j++) { A.data[k][j] /= d; B.data[k][j] /= d; } // 使A[k][j](j!=k)为0 for (int i = k + 1; i < n; i++) { double d = A.data[i][k]; for (int j = 0; j < n; j++) { A.data[i][j] -= d * A.data[k][j]; B.data[i][j] -= d * B.data[k][j]; } } } // 使A[j][k](j!=k)为0 for (int k = n - 1; k > 0; k--) { for (int i = k - 1; i >= 0; i--) { double d = A.data[i][k]; for (int j = 0; j < n; j++) { A.data[i][j] -= d * A.data[k][j]; B.data[i][j] -= d * B.data[k][j]; } } } return B; } // 单位矩阵 void eye() { if (row != col) { throw "非方阵不可转化为单位矩阵!"; } for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { data[i][j] = (i == j) ? 1 : 0; } } } // 输出矩阵元素 void print() const { for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { cout << data[i][j] << "\t"; } cout << endl; } } }; ``` 在这个矩阵类中,我们使用了动态二维数组来存储矩阵的数据。在构造函数中,我们使用了resize()函数来动态分配内存。在拷贝构造函数和赋值运算符中,我们直接复制了矩阵的行列数和数据,而不是使用浅拷贝。 在矩阵的按元素加减乘除运算中,我们首先检查了两个矩阵的维度是否匹配,然后按照对应元素相加减乘除的方式计算结果,并返回一个新的矩阵对象。 在矩阵的乘法运算中,我们首先检查了两个矩阵的维度是否匹配,然后按照矩阵乘法的定义计算结果,并返回一个新的矩阵对象。 在矩阵的转置和求逆运算中,我们使用了一些常见的线性代数算法来实现。需要注意的是,在求逆运算中,我们使用了高斯-约旦消元法来求解矩阵的逆矩阵,该算法的时间复杂度为O(n^3)。 最后,我们还实现了一个输出矩阵元素的函数print(),用于调试和测试。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值