Effective C++ 条款总结 读书笔记（一）

Item Effective C++ 条款 item_3

Use new and delete instead of malloc and free

This rule warns you if malloc and free are used in your code.   

Reason for rule: new and delete can handle constructors and destructors.

Item Effective C++ 条款 item_5

Use the same form in corresponding calls to new and delete

This rule checks calls to new and delete to make sure that they use the same form; it reports a violation if you call new but forget to use [ ] when calling delete. 

Reason for rule: If you do not use the same form in corresponding calls to new and delete, an incorrect number of destructors may be called.

Example

 /*

  * Item 5 - Use the same form in corresponding calls to

  * new and delete

  */
 class A

 {

 public:

     A() {}

 };

 

 int main()

 {

     A *a = new A[100];

     

     delete a;               // Effective C++ 条款 item item 5 violation

 }

Output

 Use the same form in corresponding

 calls to new and delete

 Violation: Effective C++ item 5

 Found new[] with delete.

Item Effective C++ 条款 item_6

Call delete on pointer members in destructors

This rule warns you if it finds a pointer member that has no corresponding delete in the destructor. 

Reason for rule: Calling delete on pointer members in destructors prevents memory leaks now and as the code evolves in the future.  

Item Effective C++ 条款 item_7

Check the return value of new

This rule warns you if you do not check the return value of new.

Reason for rule: In cases where new cannot allocate the requested memory, it will return 0.

Note: This item is suppressed by default.

Example

 /*

  * Item 7 - Check the return value of new

  */

 

 int main()

 {

     char *pc;

 

     pc = new char[10*10*10];         // Effective C++ 条款 item item 7 violation

     pc[0] = 'x';

     delete [] pc;

     return 0;

 }

Output

 Check the return value of new

 Informational: Effective C++ item 7

Item Effective C++ 条款 item_11

Define a copy constructor and assignment operator for classes with dynamically allocated memory

This rule ensures that copy constructors and assignment operators have been defined in classes with dynamically allocated memory.

Reason for rule: By defining a copy constructor and assignment operator, you achieve significant memory savings and increased speed.

Item Effective C++ 条款 item_12

Prefer initialization to assignment in constructors

This rule checks constructors to see if you are assigning data members when you should be initializing them.const and reference can only be initialized, never assigned.  

Reason for rule: If you use initialization instead of assignment, you will increase efficiency and call fewer member functions.

Exception: The only time you should use assignment instead of initialization for data members in a class is when you have a large number of data members of built-in types and you want them all to be initialized in the same way in each constructor.

 

Example

 /*

  * Item 12 - Prefer initialization to assignment in

  * constructors

  */

 
 class A

 {

 public:

     A(int i, float j) {  // Effective C++ 条款 item item 12 violation

         _idata = i;

         _fdata = j;

     }

 

 private:

     int _idata;

     float _fdata;

 };

 

 int main()

 {

     return 0;

 }

Output

 Prefer initialization to assignment

 in constructors

 Informational: Effective C++ item 12

Item Effective C++ 条款 item_13

List members in an initialization list in the order in which they are declared

This rule checks initialization lists to make sure that members are listed in the same order there as they were when declared in the class.  

Reason for rule: Class members are initialized in the order of their declaration in the class, not by the order in which they are listed in a member initialization list.

Example

 /*

  * Item 13 - List members in an initialization list in the

  * order in which they are declared

  */

 

 class A

 {

 public:

                      // Effective C++ 条款 item item 13 violation

     A(int i1, int i2, int i3) : idata3(i3), idata2(i2),

idata1(i1) {}

 

 private:

     int idata1, idata2, idata3;

 };

 

 int main()

 {

     return 0;

 }

Output

 List members in an initialization list

 in the order in which they are declared

 Violation: Effective C++ item 13

Item Effective C++ 条款 item_14

Make destructors virtual in base classes

This rule verifies that destructors in base classes are virtual.  

Reason for rule: Declaring the destructor virtual tells the compiler that it must examine the object being deleted to see where to start calling destructors.

Example

 /*

  * Item 14 - Make destructors virtual in base classes

  */

 
 class Base

 {

 public:

     Base() {}

     ~Base() {}                   // Effective C++ 条款 item item 14 violation

 };

 

 class Derived: public Base

 {

 public:

      Derived() {};

     ~Derived() {};

 };

 

 int main()

 {

     return 0;

 }

Output

 Make destructors virtual in base classes

 Severe violation: Effective C++ item 14

 Class Base is a base class but does not have a virtual

 destructor

Item Effective C++ 条款 item_15

Have operator= return a reference to *this

This rule makes sure your assignment operators return a reference to their left-hand argument, *this.  

Reason for rule: Having operator= return a reference to *this protects you from not knowing where the temporary gets destroyed and allows you to declare the operator='s parameter as a reference to const, which is safer than just declaring it to be a reference.

Example

 /*

  * Item 15 - Have operator= return a reference to *this

  */

 

 class A

 {

 public:

     explicit A(int i = 0) : _i(i) {}

     void operator=(const A& a) // Effective C++ 条款 item item 15 violation

     {

         if (&a == this) {

             return;

         }

         

         int _i = a._i;

         return;

     }

     

 private:

     int _i;

 };

 

 int main()

 {

     return 0;

 }

Output

 Have operator= return a reference to

 *this

 Severe violation: Effective C++ item 15

Item Effective C++ 条款 item_16

Assign to all data members in operator=

If you write operator=, this rule ensures that you assigned to every data member of your object.  

Reason for rule: Assigning to all data members in operator= allows you to take control of your assignments.

Example

 /*

  * Item 16 - Assign to all data members in operator=

  */

 
 class A

 {

 public:

     A() {}

     A& operator=(const A&);

 

 private:

     int _x, _y, _z;

 };

 

 A& A::operator=(const A& a)      // Effective C++ 条款 item item 16 violation

 {

     if (&a == this) {

         return *this;

     }

     

     _x = a._x;

     _y = a._y;

     

     return *this;

 }

 

 int main()

 {

     return 0;

 }

Output

 Assign to all data members in operator=

 Possible severe violation: Effective C++ item 16

 Members not assigned:

 _z

Item Effective C++ 条款 item_17

Check for assignment to self in operator=

This rule checks your code for aliasing in assignment operators.  

Reason for rule: Not checking for assignment to self in operator= can free resources that might be needed during the process of allocating new resources. Checking for assignment to self may also save you a lot of work that you would otherwise have to do to
implement assignments.

Example

 /*

  * Item 17 - Check for assignment to self in operator=

  */

 

 class A{

 public:

     A() {}

     A& operator=(A& a)               // Effective C++ 条款 item item 17 violation

     {

         _i = a._i;

         return *this;

     }

 

 private:

     int _i;

 };   

 

 int main()

 {

     return 0;

 }

Output

 Check for assignment to self in operator=

 Possible violation: Effective C++ item 17

 expected: if (&a == this) return *this;