Effective C++改善程序与设计的55个具体做法

最新推荐文章于 2022-10-10 09:39:49 发布

yangyang_z

最新推荐文章于 2022-10-10 09:39:49 发布

阅读量149

点赞数

分类专栏： C++ 文章标签： c++ 开发语言后端

C++ 专栏收录该内容

24 篇文章 2 订阅

订阅专栏

Effective C++改善程序与设计的55个具体做法-4、设计与声明

前言

前言

“让接口容易被正确使用，不容易被误用”。这个准则设立了一个舞台，让其他更专精的准则对付一个大范围的题目，包括正确性、高效性、封装性、维护性、延展性，以及协议的一致性。

条款18：让接口容易被正确使用，不易被误用

欲开发一个"容易被正确使用，不容易被误用"的接口，首先必须考虑客户可能做出
什么样的错误。假设设计一个表现日期的class设计构造函数：

class Date {
public:
	Date(int month, int day, int year);
	...
};

Date d(30,3,1995);   //应该是3,30
...

许多客户端错误可以导入新类型而获得预防。

struct Day {
	explicit Day(int d):val(d){}
	int val;
};

struct Month {
	explicit Month(int m):val(m){}
	int val;
};

struct Year {
	explicit Year(int y):val(y){}
	int val;
};

class Date {
public:
	Date(const Month&m, const Day&d, const Year& y);
};

Date d(30, 3, 1995);                  //错误！不正确的类型
Date d(Day(30), Month(3), Year(1995));//错误！不正确的类型
Date d(Month(3), Day(30), Year(1995));//OK,正确类型

class Month {
public:
	static Month Jan() { return Month(1); }  //函数，返回有效月份
	static Month Feb() { return Month(2); }
	...
	static Month Dec() { return Month(12); }
	...
private:
	explicit Month(int m);     //这是月份的专属数据
};

请记住

好的接口很容易被正确使用，不容易被误用，我们应该在我们的所有接口中努力达成这些性质。
“促进正确使用”的办法包括接口的一致性，以及与内置类型的行为兼容。
“阻止误用”的办法包括建立新类型、限制类型上的操作，束缚对象值，以及消除客户的资源管理责任。
tr1::shared_ptr支持定制型删除器(custom deleter)。这可防范DLL问题，可被用来自动解除互斥锁等等。

条款19：设计class犹如设计type

如何设计高效的classes呢？几乎每一个class都要求你面对以下提问：

新type的对象应该如何被创建和销毁？

 这会影响到class的构造函数和析构函数以及内存分配和释放函数的设计

对象的初始化和对象的赋值该有什么样的差别？

 这个答案决定你的构造和赋值操作符的行为，以及其间的差异。很重要
 的是别混淆了"初始化"和"赋值"，因为它们对应于不同的函数调用。

新type的对象如果被passed by value（以值传递），意味着什么？

 记住，copy构造函数用来定义一个type的pass-by-value该如何实现。

什么是新type的“合法值”？

 对class成员变量而言，通常只有某些数值集是有效的。哪些数值集决定
 了你的成员函数必须进行的错误检查工作。它也影响函数抛出的异常、
 以及函数异常明细列。

你的新type需要配合某个继承图系(inheritance graph)吗？

 如果继承自某些既有的classes，就受到那些classes的设计束缚，
 特别是受到“它们的函数是virtual或non-virtual”的影响。如果
 允许其他classes继承你的class,那会影响你所声明的函数是否为virtual。

你的新type需要什么样的转换？
什么样的操作符和函数对此新type而言是合理的？
什么样的标准函数应该驳回？
谁该取用新type的成员？
什么是新type的“未声明接口”(undeclared interface)？
你的新type有多么一般化？
你真的需要一个新type吗？

条款20：宁以pass-by-reference-to-const替换pass-by-value

缺省情况下C++以by value方式传递对象至函数。除非另外指定，否则函数参数
都是以实际实参的复件为初值，而调用端所获得的亦是函数返回值的一个复件。
这些复件系由对象的copy构造函数产出，这可能使得pass-by-value成为昂贵的操作。

class Person {
public:
	Person();
	virtual~Person();
private:
	std::string name;
	std::string address;
};

class Student :public Person {
public:
	Student();
	~Student();
private:
	std::string schoolName;
	std::string schoolAddress;
};

bool validateStudent(Student s);
Student plato;
bool platoIsOK = validateStudent(plato);

以by value方式传递一个Student对象，总体成本是“六次构造六次析构”！！！

回避那些构造和析构的动作，通过pass by reference-to-const:

bool validateStudent(const Student &s);

这种传递方式效率高的多：没有任何构造函数或析构函数被调用，因为没有任何
新的对象被创建。

class Window {
public:
	std::string name() const;
	virtual void display() const;
};

class WindowWithScrollBars :public Window {
public:
	virtual void display()const;
};

假设你写个打印窗口函数名称，然后显示该窗口

void printNameAndDisplay(Window w)  //不正确，参数可能被切割
{
	std::cout << w.name();
	w.display();
}

解除切割(slicing)问题的办法，就是以by reference-to-const的方式传递w

void printNameAndDisplay(const Window&w)
{
	std::cout << w.name();
	w.display();
}

请记住

尽量以pass-by-reference-to-const替换pass-by-value。前者通常比较高效，并可避免切割问题。
以上规则并不适用于内置类型，以及STL的迭代器和函数对象，对它们而言pass-by-value往往比较适当。

条款21：必须返回对象时，别妄想返回其reference

不要返回局部变量的引用

const Rational& operator*(const Rational & lhs, const Rational & rhs)
{
	Rational result(lhs.n*rhs.n, lhs.d*rhs.d);
	return result; //不要返回局部变量的引用,局部变量在函数退出前被销毁
}

请记住

绝不要返回pointer或reference指向一个local stack对象，或返回reference指向一个heap-allocated对象，或返回pointer或reference指向一个local static对象而有可能需要多个这样的对象。

条款22：将成员变量声明为private

class AccessLevels {
public:
	int getReadOnly()const { return readOnly; }
	int setReadWrite(int value) { readWrite = value; }
	int getReadWrite()const { return readWrite; }
	void setWriteOnly(int value) { writeOnly = value; }
private:
	int noAcess;
	int readOnly;
	int readWrite;
	int writeOnly;
};

请记住

切记将成员变量声明为private。这可赋予客户访问数据的一致性，可细微划分访问控制、允诺约束条件获得保证，并提供class作者以充分的实现弹性。
protected并不比public更具有封装性。

条款23：宁以non-member、non-friend替换member函数

class WebBrowser {
public:
	//调用clearCache,clearHistory和removeCookies
	void clearEverything();
};

class WebBrowser {
public:
	void clearCache();
	void clearHistory();
	void removeCookies();
};



void clearBrowser(WebBrowser&wb)
{
	wb.clearCache();
	wb.clearHistory();
	wb.removeCookies();
}

将所有的便利含还是放在多个头文件内但隶属同一个命名空间，意味客户可以轻松
扩展这一组便利函数。


//头文件 "webbrowser.h"
namespace WebBrowserStuff {
	class WebBrowser{};
	//...     //核心技能，例如几乎所有用户都需要
			  //non-member函数
}

//头文件"webbrowserbookmarks.h"
namespace WebBrowserStuff {
	//... //与书签相关的便利函数
}

//头文件"webbrowsercookies.h"
namespace WebBrowserStuff {
	//...  //与cookie相关的便利函数
}

请记住

宁可拿non-member non-friend函数替换member函数。这样做可以增加封装性、包裹弹性和技能扩展性。

条款24：若所有参数皆需类型转换，请为此采用non-member函数

请记住

如果你需要为某个函数的所有参数(包括被this指针所指的那个隐喻参数)进行类型转换，那么这个函数必须是个non-member。

条款25：考虑写一个不抛异常的swap函数

namespace std {
	template<typename T>
	void swap(T&a, T&b) {
		T temp(a);
		a = b;
		b = temp;
	}
}

class WidgetImpl {
public:
...
private:
	int a, b, c;
	std::vector<double> v;   //意味着复制时间很长
	...
};

class Widget {
public:
	Widget(const Widget&rhs);
	Widget&operaor = (const Widget&rhs)
	{
		*pImpl = *(rhs.pImpl);
	}

private:
	WidgetImpl *pImpl;   //指针，所指的对象内含Widget数据
};

请记住

当std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常。
如果你提供一个member swap，也该提供一个non-member swap用来调用前者。对于classes（而非templates）,也请特化std::swap
调用swap时应针对std::swap使用using 声明式，然后调用swap并且不带任何"命名空间资格修饰"。
为“用户定义类型”进行std templates全特化是好的，但千万不要尝试在std内加入某些对std而言全新的东西。