Effective C++ 笔记（2）

1.       继承与面向对象设计

条款32: 确定你的public继承塑模出is-a关系

条款33: 避免遮掩继承而来的名称

无论是virtual或non-virtual, 如果derived class有复写，则屏蔽了virtual函数.编译器首先寻找derived作用域中函数名，再寻找base，如果找到则停止，并不判断参数．

 class base

{

public:

         virtual void mf1();

         virtual void mf1(int);

         virtual void mf2();

         void mf3();

         void mf3(int);

};

class derived: public base

{

public:

         virtual void mf1();

         void mf3();

         void mf4();

}

derived d;

d.mf1(); //ok, derived::mf1;

d.mf1(1); //error, derive::mf1() cover base::mf1()

d.mf2(); //ok, base::mf2()

d.mf3(); //ok, derived::mf3();

d.mf3(1); //error, derive::mf3() cover base::mf3()

 

derived d;

base *p = &d;

p->mf1(); // derived, base::mf1;

p->mf3();//ok, base::mf3;

这违背is-a关系，可以使用using声明

class derived: public base

{

public:

         using base::mf1; /*让base中名为mf1,mf3的所有东西在derived作用域中可见*/

         using base::mf3;

         virtual void mf1();

         void mf3();

         void mf4();

};

条款34: 区分接口继承和实现继承

 pure virtual: 只继承接口

simple virtual: 继承接口和缺省实现

non-virtual: 如果在derived class中重写则覆盖,所以不应覆写,代表的是不变性和凌驾特异性,继承接口和一份强制实现

class airport{};

class airplane

{

public:

         virtual void fly(const airport &);

};

class airplaneA: public airplan

{

//未定义fly函数,继承airplan::fly

};

class airplaneB: public airplan

{

//未定义fly函数,继承airplan::fly

};

如果derived有共同行为,可以将函数共同行为定义在base class中，随之而来的问题是，如果有增加一个derived class行为不同且未重定义函数,则造成错误.

class airplaneC: public airplan

{

//未定义fly函数,继承airplan::fly,但是airplaneC fly方式不同，出错!!

};

所以需要将接口和缺省分开.

class airplane

{

public:

         virtual void fly(const airport &) = 0;

protected:

         void defaultfly(const airport &);

};

class airplanA: public airplan

{

         virtual void fly(const airport &destination)

         {

                   defaultfly(destination);

         }

};

class airplanB: public airplan

{

                   virtual void fly(const airport &destination)

         {

                   defaultfly(destination);

         }

};

class airplanC: public airplan

{

                   virtual void fly(const airport &destination)

         {

                   //C own fly mode

         }

};

或者(个人喜欢后者)：

class airplane

{

public:

         virtual void fly(const airport &) = 0;

 

};

void airplane::fly(const airport &destination)

{

         //default fly mode

}

class airplanA: public airplan

{

         virtual void fly(const airport &destination)

         {

                   airplane::fly(destination);

         }

};

class airplanB: public airplan

{

         virtual void fly(const airport &destination)

         {

                   airplane::fly(destination);

         }

};

class airplanC: public airplan

{

         virtual void fly(const airport &destination)

         {

                   //C own fly mode

         }

};

 

条款35: 考虑virtual函数以外的其他选择

NVI手法，non-virtual interface,这个思想流派主张virtual函数应该几乎总是private．而创建另一个non-virtual函数调用virtual函数,做一些事前工作或时候工作．

class airplane

{

public:

         int fly()

         {

                   //...

                   dofly();

                   //...

         }

private:

         virtual void dofly(const airport &) ;

}

另一种strategy：

class airplane;

int defaultfly();

 class airplane

{

public:

         typedef void (*pflymodefunc)();

         explicit airplane(pflymodefunc ff = defaultfly) :flyfunc(ff)

         {

         }

         void fly() const

         {

                   flyfunc();

         }

private:

         pflymodefunc flyfunc ;

};

class myairplane: public airplane

{

         explicit airplaneA(pflymodefunc ff = defaultfly)

                   : airplane (ff)

         {

         }

 

};

void airplaneA_fly(void);

void airplaneB_fly(void);

myairplane planeA(airplaneA_fly); //不同的飞行方式

myairplane planeB(airplaneB_fly); //不同的飞行方式

借由tr1::function完成strategy模式

class airplaneC_fly

{

         void operator ()(void) const

         {

         }

};

class airplane

{

public:

         typedef std::tr1::function<void ()> pflymodefunc;

/*void ()代表的是无参数，返回值为void的函数, tr1::function类型产生的对象可以持有任何遇刺签名式兼容的可调用物, 所为兼容,是指调用的变量可以隐式转换为参数类型,而实际返回值可以转换为返回值类型*/

         explicit airplane(pflymodefunc ff = defaultfly)

                   :flyfunc(ff)

         {

         }

         void fly() const

         {

                   flyfunc();

         }

private:

         pflymodefunc flyfunc ;

};

void airplaneA_fly(void);

myairplane planeA(airplaneA_fly); //不同的飞行方式

myairplane planeC(airplaneC_fly()); //不同的飞行方式,函数对象

 

古典的strategy模式

将继承体系内的virtual函数替换为另一个继承体系内的virtual函数．

class flymode

{

         virtual void fly()

         {

         }

};

flymode defaultflymode;

class airplane

{

public:

         typedef std::tr1::function<void ()> pflymodefunc;

 

         explicit airplane(flymode ff = defaultfly)

                   :pflymode(ff)

         {

         }

         void fly() const

         {

                   pflymode->fly();

         }

private:

         flymode pflymode ;

};

 

条款36: 绝不重新定义继承而来的non-virtual函数

对于动态绑定, 如果是virtual函数, 则现在derived class中寻找，如果没有寻到, 则在base class中寻找, 如果是non-virtual,则直接在base class中寻找．

class base

{

public:

         virtual void func1();

         void func2();

}

class derived: public base

{

public:

         virtual void func1();

         void func2();

}

base *p = new derived();

p->func1(); //derived::func1()

p->func2(); //base::func2()

delete p;

derived d;

d->func2(); //derived::func2()

 

条款37: 绝不重新定义继承而来的缺省函数值

virtual系数是动态绑定，而缺省函数值却是静态绑定.

class base

{

public:

         virtual void func1(int i = 0);

         virtual void func2(int i = 0);

};

class derived: public base

{

public:

         virtual void func1(int i = 1);

};

class derived2: public base

{

public:

         virtual void func2(int i);

};

base *p = new derived();

p->func1(); //derived::func1(0) , 动态绑定时, 默认参数从base继承

delete p;

 *p = new derived2();

p->func2(); //base::func2(0) , 动态绑定时, 默认参数从base继承

delete p;

 

derived2 d2;

d2->func2(1); //静态绑定时, 不继承默认实参

d2.func2(); /* error, 'derived::func2' : function does not take 0 arguments*/

 

条款38: 通过复合塑模出has-a或根据某物实现出

条款39: 明智而谨慎地使用private继承

如果classes之间的继承关系是private, 编译器不会自动将一个derived class对象转换为一个base classs对象. private继承只是一种实现技术，private继承意味只有实现部分被继承，接口部分被略去.

class base{};

class derived: private base{};

void func(const base&); //或者void func(const base)；

derived a;

func(a); /* error, 'type cast' : conversion from 'derived *__w64 ' to 'const base &' exists, but is inaccessible*/

 

private继承类似has-a, base的某些接口不想让用户使用或误用, 但需要重写某些virtual函数,使用private继承．

class Timer

{

public:

         virtual void onTick(int i = 0); //call it once timer stricked

};

class myTimer: private Timer

{

private：

virtual void onTick(int i = 0);

};

 

可用复合代替

class Timer

{

public:

         virtual void onTick(int i = 0); //call it once timer stricked

};

class myClass

{

private:

         class myTimer: public Timer

         {

         public:

                   virtual void func2(int i);

         }

         derived d;

};

 

如果class无成员变量, 无virtual function(无vptr)，无virtual base classed(这样的base class也会带来体积上的额外开销), 这样的empty class不使用任何空间, 但是C++判定，独立对象必须有非零大小．

class empty

{

};

classs derived{

private:

         int x;

         empty e:

}

sizeof (derived) > sizeof(int);

sizeof(empty) == 1 /*或者更大(齐位要求)*/

C++会默默安插一个char到空对象内，但是这个约束不适合derived class对象内的base clas成分．

classs empty_derived: private empty

{

private:

         int x;

}

sizeof(empty_derived) == sizeof(int); /*EBO(empty base optimization; 空白基类最优化, 一般只在单一继承下才可行*/

 

条款40: 明智而谨慎地使用多重继承

 virtural继承的classs所产生的对象比使用non-virtual继承的class体积大,且访问成员的速度慢, 而且virtual base class的初始化由最底层derived class负责,如果非必要, 不要使用virtual继承．

但是多重继承涉及 public继承某个interface class(pure virtual class), private继承某个写组实现的class的组合, 则正当．

 

7. 模板与泛型编程

 

条款41: 了解隐式接口和编译期多态

条款42: 了解typename的双重意义.

typename比较class多了一个意义: 声明是嵌套从属名称.

template<typename T>void func(ITerT iter)

{

         C::const_iterator *x; /*编译期认为C::const_iterator不是类型而是变量, 如果C::const_iterator是一个变量,则*代表乘号.*/

typename C::const_iterator *x; //ok

typename  std::iterator_traits<ITerT>::value_type temp(iter); /*代表对象所指物的类型,如果ITerT是vector<int>iterator,则temp就是int*/

}

template不可再base classes list内,也不可再member initialization list中作为base class的 修饰符.

 

条款43: 学习处理模板化基类内的名称

template<typename T> class base

{

         void func();

}

template<typename T> class derived: public base<T>

{

         void func2()

         {

                   func(); /*不能通过编译,有可能基类被特例化而无func函数,所以func对编译器不可见.*/

         }

}

template<c> class base<classtype>

{

//无func函数.

}

需要在derived中使用using声明

template<typename T> class derived: public base<T>

{

using base<T>::func;

         void func2()

         {

                   func(); //不能通过编译,有可能基类被特例化而无func函数.

         }

}

或者

template<typename T> class derived: public base<T>

{

         void func2()

         {

                   this->func(); //不能通过 ?译,有可能基类 被特例化而无函数.

         }

}

 

derived<classtype> d;

d.func2(); //编译错误.

 

条款44: 将与参数无关的代码抽离templates

条款45: 运用成员函数模板接受所有兼容类型

智能指针

template<typename T>class smrtptr

{

public:

template<typename U>smartptr(const SmartPtr<U> &other): ptr(other.get())

         {

         }

/*编译器会自动生成copy构造函数smartptr(smart const&)*/

         explicit smartptr<T *other>;

         //...

         T *get() const

         {

                   return ptr;

         }

private:

         T *ptr;

};

smartptr<base> ptr = smart<derived>(new derived);

 

条款46: 需要类型转换时请为模板定义非成员函数

template<typename T>class myclass

{

public:

         myclass(const T &n = 0, const T &d = 1);

};

template<typename T> const myclass<T> operator *(const myclass<T> &lhs, const myclass<T> &rhs)

{

}

myclass<int> onehalf(1, 2);

myclass<int>result = onehalf * 2; /* error, 'const myclass <T> operator *(const empty<T> &,const empty<T> &)' : could not deduce template argument for 'const empty<T> &' from 'int' , template无法通过构造函数隐式进行隐式类型转化, 所以无法将2转换为myclass<int>从而将T推断为int．*/

 

template<typename T>class empty

{

public:

         empty(const T &n = 0, const T &d = 1){}

         friend

         const empty operator *(const empty &lhs, const empty &rhs); /*被声明却没被定义.*/

};

template<typename T> const empty<T> operator *(const empty<T> &lhs, const empty<T> &rhs)

{

}

empty <int> onehalf(1, 2);

empty <int>result = onehalf * 2; /*无法link, error LNK2028: unresolved token (0A00029C) "class empty<int> const __cdecl operator*(class empty<int> const &,class empty<int> const &)" (??D@$$FYA?BV?$empty@H@@ABV0@0@Z) referenced in function "int __cdecl main(int,char * * const)" (?main@@$$HYAHHQAPAD@Z)*/

由于onehalf被声明为empty<int>则class empty<T>被具化, 而friend函数operator *也被自动声明, 所以编译其可以使用构造函数进行隐式转换.

 

template<typename T>class empty

{

public:

         empty(const T &n = 0, const T &d = 1){}

         friend

         const empty operator *(const empty &lhs, const empty &rhs)

{

}

};

empty <int> onehalf(1, 2);

empty <int>result = onehalf * 2;　//ok

 

条款47: 请使用traits classed表现类型信息

条款48: 认识template元编程

 

8 定制new和delete

条款49: 了解new-handler的行为

当operator new抛出异常以反映一个未获满足的内存需求之前, 它会先调用一个客户指定的错误处理函数, 一个所谓的new-handler, 调用set_new_handler函数, 声明于<new>的一个标准程序库函数.

namespace std

{

         typedef void (*new_handler)();

         new_handler set_new_handler(new_handler p) throw(); /*返回旧的handler*/

}

class专属new-handler

class myclass

{

public:

         static std::new_handler set_new_handler(std::new_handler p) throw();

         static void* operator new(std::size_t size) throw(std::bad_alloc);

/*调用set_new_handler, call global operator new, 分配失败，则会调用new_handler, 如果最终无法分配足够内存, 抛出bad_alloc, 此情况下, 必须确保原本的new_handler恢复, 如果分配成功, 返回指针, 析构函数需要将原本的handler恢复*/

private:

         static std::new_handler currenthandler;

};

static std::new_handler myclass ::currenthandler = NULL;

std::new_handler myclass::set_new_handler(std::new_handler p) throw()

{

         std::new_handler oldhandler = currenthandler;

         currenthandler = p;

         return oldhandler;

}

void* myclass::operator new(std::size_t size) throw(std::bad_alloc)

{

         newhandlerholder(std::set_new_handler(currenthandler));

         return std::operator new(size);

}

 

下列class, newhandlersupport, 虽然没有用到T, 但是使用template是为了让每一个拥有异体的newhandersupport(更确切地说是currenthandler)

template<typename T>

class newhandlerholder

{

public:

         explicit newhandlerholder(std::new_handler):handler(nh){}

         ~newhandlerholder(){std::set_new_handler(handler)}

 

private:

         std::new_handler handler;

         newhandlerholder(const newhandlerholder&);

         newhandlerholder& operator=(newhandlerholder &);

};

template<typename T>

class newhandlersuport

{

public:

         static std::new_handler set_new_handler(std::new_handler p) throw();

         void* operator new(std::size_t size) throw(std::bad_alloc)

         {

                   newhandlerholder(std::set_new_handler(currenthandler));

                   return std::operator new(size);

         }

private:

         static std::new_handler currenthandler;

};

template<typename T> std::new_handler newhandlersuport<T>::currenthandler = NULL;

template<typename T> std::new_handler newhandlersuport<T>::set_new_handler(std::new_handler p) throw()

{

         std::new_handler oldhandler = currenthandler;

         currenthandler = p;

         return oldhandler;

}

class empty: public newhandlersuport<empty>

{

};

 

9: 杂项讨论

条款53: 不要轻忽编译器的警告

条款54: 让自己熟悉包括TR1在内的标准程序库

条款55: 让自己熟悉Boot