void main() { }

Hello ,world !

常用链接

统计

最新评论

Effective C++ 学习历程002

      既然开始了，那就继续吧，每一个单元包含其中的5个条款。
主要内容就是代码的了，但是代码中也包含了一些注释。而这些
代码都是为各自对应的条款服务的，有些可以值得推敲。希望对
你有些帮助。ok，谢谢！
  1 // ====================================================================
  2 // --- 条款06：若不想实验编译器自动生成的函数，就该明确拒绝
  3 // 注意：
  4 // 1    为驳回编译器自动（暗自）提供的机能，可将相应的成员函数声明为private or protected
  5 //      并且不予实现。使用像Uncopyable这样的base class 也是一种做法
  6 namespace testItem06
  7 {
  8     class Uncopyable
  9     {
 10     protected:
 11         Uncopyable() {}
 12         ~Uncopyable() {}
 13     private:
 14         Uncopyable(const Uncopyable&) ;
 15         Uncopyable& operator = (const Uncopyable&) ;
 16     } ;
 17     class HomeForSale : private Uncopyable
 18     { // 
 19     } ;
 20 }//namespace testItem06
 21 // ====================================================================
 22 // --- 条款07：为多态基类声明virtual 析构函数 
 23 // 注意：
 24 // 1    polymorphic（多态的）base class 应该声明一个virtual 析构函数。
 25 //      如果class带有任何virtual函数，她应该拥有一个virtual析构函数
 26 // 2    class 的设计目的如果不是作为base class使用，或不是为了具备多态性
 27 //      就不应该声明一个virtual 析构函数 
 28 // 3
 29 namespace testItem07
 30 {
 31     class TimeKeeper
 32     {
 33     public:
 34         TimeKeeper() {};
 35         virtual ~TimeKeeper() {};
 36         // should virtual for delete pBase ;//destroy exactly
 37         // 
 38     } ;
 39     class AtomicClock : public TimeKeeper{ } ;// 
 40     class WaterClock : public TimeKeeper{ } ;// 
 41     class WristClock : public TimeKeeper{ } ;// 
 42     class AWOV
 43     {
 44     public:
 45         virtual ~AWOV() = 0 ;
 46     } ;
 47     AWOV::~AWOV() {} //must has a defalut definition
 48 }
 49 // ====================================================================
 50 // --- 条款08：别让异常逃离析构函数 
 51 // 注意：
 52 // 1    析构函数绝对不要吐出异常。如果一个呗析构函数调用的函数可能抛出异常，
 53 //      那么在析构函数内应该捕捉任何异常，然后吞下它们（不传播）或是结束程序
 54 // 2    如果客户需要对某个操作函数运行期抛出的异常做出反应，那么class 应该提供
 55 //      一个普通的函数（而非在系后函数中）执行该操作 
 56 // 3
 57 namespace testItem08
 58 {
 59     class DBConnection
 60     {
 61         // .
 62     public:
 63         void start() {}
 64         void close() {}
 65         // .
 66     } ;
 67     class DBConn
 68     {
 69     private:
 70         bool   bClose_ ;
 71         DBConnection db ;
 72     public:
 73         void start() //
 74         {
 75             db.start() ;
 76             bClose_ = false ;
 77         }
 78         void close() // better .note 2
 79         {
 80             db.close() ;
 81             bClose_ = true ;
 82         }
 83         ~DBConn()// better .
 84         {
 85             if(!bClose_)
 86             {
 87                 try
 88                 {
 89                     db.close() ;
 90                 }
 91                 catch()
 92                 {// better .note 1
 93                     handleError() ;// or: db.close() again 
 94                     bClose_ = false ;
 95                 }
 96             }
 97         }
 98     protected:
 99         void handleError() {} // 
100     } ;
101 }//namespace testItem08
102 // ====================================================================
103 // --- 条款09：绝不vuz构造和析构过程中调用virtual 函数 
104 // 注意：
105 // 1    在构造和析构过程中不要调用virtual函数，因为这类调用从不下降只derived class
106 //      （比起当前执行构造和析构函数的那一次 class）
107 // 2
108 // 3
109 namespace testItem09
110 {
111     class Transaction_Bad
112     {
113     private:
114         int     value_ ;
115     public:
116         Transaction_Bad() ;
117         virtual void logTransaction_Bad() const = 0 ;
118     } ;
119     Transaction_Bad::Transaction_Bad()
120     {   // 
121         //logTransaction_Bad() ; // warn !!! or error
122     }
123     void Transaction_Bad::logTransaction_Bad() const
124     { std::cout << "  virtual void Transaction_Bad::logTransaction_Bad() const\n" ; }
125     class BuyTransaction_Bad : public Transaction_Bad
126     {
127     public:
128         //BuyTransaction_Bad():Transaction_Bad() {}
129         virtual void logTransaction_Bad() const
130         { std::cout << "  virtual void BuyTransaction_Bad::logTransaction_Bad() const\n" ; }
131     } ;
132     class SellTransaction_Bad : public Transaction_Bad
133     {
134     public:
135         //BuyTransaction_Bad():Transaction_Bad() {}
136         virtual void logTransaction_Bad() const
137         { std::cout << " virtual void SellTransaction_Bad::logTransaction_Bad() const\n" ; }
138     } ;
139     // --------------
140     class Transaction_Good
141     {
142     public:
143         explicit Transaction_Good(const std::string& logInfo)  ;
144         void logTransaction_Good(const std::string& logInfo) const  ;//non-virtual
145     } ;
146     Transaction_Good::Transaction_Good(const std::string& logInfo)
147     {
148         // 
149         logTransaction_Good(logInfo) ; // warn !!!
150     }
151     void Transaction_Good::logTransaction_Good(const std::string& logInfo) const
152     {
153         std::cout << " void Transaction_Good::logTransaction_Good(const std::string& logInfo) const\n"
154                   << " logInfo: " << logInfo << "\n" ;
155     }
156     class BuyTransaction_Good : public Transaction_Good
157     {
158     private:
159         static string createLogStr(int index)
160         { return " static string BuyTransaction_Good::createLogStr(int index)" ; }
161     public:
162         BuyTransaction_Good(int index):Transaction_Good(createLogStr(index))
163         {} // 
164         virtual void logTransaction_Good() const
165         { std::cout << " virtual void BuyTransaction_Good::logTransaction_Good() const\n" ; }
166     } ;
167     class SellTransaction_Good : public Transaction_Good
168     {
169     private:
170         static string createLogStr(int index)
171         { return " static string SellTransaction_Good::createLogStr(int index)" ; }
172     public:
173         SellTransaction_Good(int index):Transaction_Good(createLogStr(index))
174         {} // 
175         virtual void logTransaction_Good() const
176         { std::cout << " virtual void SellTransaction_Good::logTransaction_Good() const\n" ; }
177     } ;
178 }//namespace testItem09
179 // ====================================================================
180 // --- 条款10：令operator= 返回一个 referance to *this
181 // 注意：
182 // 1    令赋值（assignment）操作符返回一个 reference tio *this 
183 namespace testItem10
184 {
185     class Widget
186     {
187     private:
188         int value_ ;
189     public:
190         //Widget():value_(0) {} //  or remove
191         Widget(int v=0):value_(v) {}
192         Widget& operator = (const Widget& rhs) ;
193         Widget& operator += (const Widget& rhs) ;
194         void printW()
195         { std::cout << " Widget::value_: " << value_ << "\n" ; }
196         // 
197     } ;
198     Widget& Widget::operator = (const Widget& rhs)
199     {
200         value_ = rhs.value_ ;
201         return *this ;
202     }
203     Widget& Widget::operator += (const Widget& rhs)
204     {
205         value_ += rhs.value_ ;
206         return *this ;
207     }
208 }


posted on 2010-05-30 15:35 only 阅读(196) 评论(0)  编辑 收藏 引用 所属分类: 学习研究 、琐碎编程


只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理