标签:c++ effective c++ 笔记
//---------------------------15/04/06----------------------------
//#18 让接口容易被正确使用,不易被误用
{
// 1:为了防止客户输入错误的参数,可以使用外覆类型来区别:
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 class:
Date d(Month(3), Day(30), Year(1995));
// 为了限制类型的值,比如一年只有12个月,Month应该反映这样的事实。
// 为了安全不直接使用enum,而是预先定义所有有效的Months:
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);
};
Date d(Month::Mar(), Day(30), Year(1995));
/* 2:预防客户错误的另一个办法是:限制类型内什么事可做,什么事不能做。也就是加上const。
3:除非有好理由,否则应该尽量令你的types的行为与内置types一致
4:任何接口如果要求客户必须记得做某些事情,就是有着“不正确使用”的倾向。
较佳接口的设计原则是先发制人,比如条款13中,
令factory函数返回一个智能指针,可以避免客户忘记使用智能指针: */
std::tr1::shared_ptr<Investment> createInvestment();
// 5:tr1::shared_ptr支持定制型删除器,可以防范DLL问题:
std::tr1::shared_ptr<Investment> createInvestment()
{
std::tr1::shared_ptr<Investment> retval(static_cast<Investment*>(0),
getRidOfInvestment);
retval = ...;
return retval;
}
}
//#19 设计class犹如设计type
{
/* 1:新type的对象应该如何被创建和销毁?
这会影响到你的class的构造函数和析构函数,以及内存分配函数和释放函数。
当然前提是如果你打算撰写他们。
2:对象初始化和对象的赋值该有什么样的差别
这个答案决定了构造函数和赋值操作符的行为,以及差异。
3:新type的对象如果被passed by value,意味着什么?
copy构造函数用来定义一个type的pass by value该如何实现。
4:什么是新type的“合法值”
你的class必须维护自己的约束条件,也就决定了你的成员函数
(特别是构造函数、赋值操作符、和所谓的setter函数)必须进行错误检查工作。
5:你的新type需要配合某个继承图系吗?
继承既有的class会受到哪些class的设计的束缚,特别是他们的函数是virtual或non_virtual的影响
如果允许别人继承自己的类,就会影响你所声明的函数是否为virtual
6:你的新type需要什么样的转换
是否需要隐式转换、显式转换。
7:什么样的操作符和函数对此新type而言是合理的?
这个答案决定你为你的class声明哪些函数,其中某些该是member函数。
8:什么样的标准函数应该驳回
你不想要系统为你声明的函数要声明为private。
9:谁该取用新type的成员
这个答案决定了哪个成员为public,protected,private。以及哪个class或function应该是friend
10:什么是新type的“为声明接口”
它对效率、异常安全性以及资源运用提供何种保证
11:你的新type有多么一般化
看看自己是否应该定义一个新的class template
12:你真的需要一个新type吗
如果只是为既有的class添加机能,那么可能单纯定义一个或多个non member函数或templates
更能达到目标。
*/
}
//#20 宁以pass by reference to const替换pass by value
{
/* 1:pass by value 需要调用copy构造函数产出一个副本,这可能使得pass by value
成为昂贵的操作。如果传递的是一个自定义class,通常需要调用一次copy构造函数 加 一次析构函数
如果这个class继承自别的类,又需要多调用好几次这两个函数。
2:by reference方式传递参数可以避免slicing(对象切割)问题:
一个derived class 对象以by value方式传递并被视为一个base class对象时,base class
的copy构造函数被调用,而“造成此对象的行为属于derived class 对象”的部分被切掉了,只留
下了一个base class对象。这绝不是你想要的。
3:reference通常以指针来实现出来,所以pass by reference就相当于传递指针。因此如果是一些
内置类型对象(比如int) pass by value 往往比 pass by reference的效率高些。
4:除了内置类型 和 stl的迭代器和函数对象,其他的对象都以pass by reference to const
替换 pass by value。
*/
}
//#21 必须返回对象时,别妄想返回其reference
{
// 1:一些值必须返回pass by value:
// 1>通过在stack上创建对象并返回这个对象的引用:
const Rantional& operator* (const Rantional& lhs, const Rantional& rhs)
{
Rantional result(lhs.n * rhs.n, lhs.d * rhs.d);
return result;
}
/* 这里有两个点:
1)这样也调用构造了,效率并没提高。
2)返回了一个已经被销毁的对象。严重的错误!
2>通过在堆上创建对象并返回这个对象的引用:
*/
const Rantional& operator*(const Rantional& lhs, const Rantional& rhs)
{
Rantional result = new Rantional(lhs.n * rhs.n, lhs.d * rhs.d);
return result;
}
// 这样的话,谁负责delete?而且还是需要一次构造函数。
// 3>使用static对象:
const Rantional& operator* (const Rantional& lhs, const Rantional& rhs)
{
static Rantional result;
result = ...;
return result;
}
// 这样首先线程不安全,其次使用if((a * b) == (c * d))总是返回true;
// 2:当一个函数必须返回新对象时,就让那个函数返回一个新对象呗!
inline const Rantional operator* (const Rantional& lhs, const Rantional& rhs)
{
return Rantional(lhs.n * rhs.n, lhs.d * rhs.d);
}
}
//#22 将成员变量声明为private
{
/* 1:首先看看成员变量不该是public:
1>一致性:如果没有public成员变量,客户唯一能访问对象的办法就是使用成员函数
客户就不需要在访问成员时疑惑地试着记住是否使用小括号。
2>可以更加精准地控制成员变量:你可以通过函数控制成员变量的读写。
3>封装性:如果通过函数访问成员变量,日后就算更改了这个变量的计算方法,或者直接更改了变量,
客户也不知道,也不必知道。
不封装就意味着不改变。
2:成员变量不该是protected:
道理和public第三点一样,这样对derived class并没有封装性可言
}
标签:c++ effective c++ 笔记
原文地址:http://blog.csdn.net/boydfd/article/details/44906649