读书笔记：《Effective C++》

Effective C++

GitHub - taeguk/Effective-Cpp-Series: My example and experimental source codes about books of Effective C++ Series, “Effective C++ 3/E” and “Effective Modern C++” by Scott Meyers.

C++ Basic

C++ Union

C
Object Oriented C++
Template C++
STL
TR1 - Boost

Using const，enum，inline instead of #define

constant：using const or enum
- static int constant can not have in-class definition
  - using enum hack：enum { ConstNum = 5 };
function macros：using inline function

Using const whenever possible

bitwise constness: c++ const
logical constness: mutable field
call const function in non-const override functin, to avoid code redundant

Make sure init before use

in construct function:
- using member init list instead of assignment inside function
- order by class-field-define-order in init list
using static object in-function instead of global static object
- return reference of static local object

Constructor，Destructor， Assignment op

Silent functions in class

default construction
default copy construction
operator=
destruction
explicitly use silent functions
- = default

Explicitly delete silent functions

make private
make delete
move private or delete to a base class and private extend

Virtual destructors in polymorphic

use virtual destruction in polymorphic base class

Non-throw destructors

handle exceptions out of destruction
abort when destruction meet exceptions
ignore exceptions in destruction

No virtual call in construction and destruction

in construction or destruction, virtual call can not goto derived class

Operator= return *this

return *this in operator= to support multi =

Operator= handle self-assignment

make sure good condition when self-assignment

Deep copy when copy

copy construction
- call base copy construction
operator=
- call base operator=
do not call copy construction in operator=, or otherwise

Resource Management

Using resource-managing class

using RAII class
- new resource when construction
- delete resource when destruction
using smart pointers

Copying resource-managing class

disable copying: unique ptr
reference count: shared ptr
deep copy resource
move raw resource

Access raw in resource-managing class

implict cast: use operator(), can be unsafe
explict cast: use get(), more safer

Same form in new and delete

new and delete
new[] and delete[]

Standalone statement when smart pointers

give new resource to smart pointer in one statement
- using make_shared, though it will keep reference count when having weak ptr
construct smart pointer in standalone statement
- to avoid other part of statement has exceptions

Design

Make interface to easy use

make new type or enum，static or const value，to make use correctly

Design class as type

does a new type is really needed
- consider using non-member to replace a simple derived class

Pass by const reference instead of value

consider pass by const reference in all place
pass by value when standard types or function object

Dont return reference

do not return reference of stack or heap value

Make data member private

public data member expose the implement details
- when change public，all user must be changed
- when change protected，all derived must be changed

Non-member instead of member function

non-member function can only use public interface, and keep the encapsulation

Non-member function when type conversion

member function can not conversion the caller’s type, while non-member function can

Non-throw swap

using std::swap
using std::swap in member swap
using member swap in non-member swap

Implementation

Postpone variable definitions

avoid early returns case no-use variable
consider re-construction or keep the variable to operator=

Consider casting

dynamic cast is low efficiency
C cast:
- (T)exp
- T(exp)
C++ cast:
- const cast
- dynamic cast
- static cast
- reinterpret cast

Avoid return handles of object internals

when return handles of object internals, not only the function is const, also the return is const
- const InternalHandle func() const

Strive for exception safe

exception safe:
- when exception, no memery leak, no fake state
exception safe level:
- base exception safe: when exception, no memery leak, no fake state
- force exception safe: when exception, function is full completed or none completed
  - copy and swap
- nothrow exception safe: no exception

Inlining

inline is an advice, not a request
when inline function changed, all dependence file must be re-compile
when non-inline function changed, only need to re-link

Compilation dependency

only declare class in classfwd.h, and define those in class.h
- class declare no change, only change class definition
handle class: implementation pointer to implementation class
- handle class no change, only change implementation class
- additional memory resource management
interface class: vptr to virtual function
- base class no change, only change derived class
- addition virtual table cost

Inheritance and OOP

Public inheritance means is-a

make sure public inheritance means is-a relationship
- not has-a relationship
- not implement-of relationship

Avoid hiding base class through overwrite

the same name in child class will hide those in base class, though parameters are different
- using BaseClass::function for not hiding
- BaseClass::function directly for using once

Interface extend and implementation extend

pure virtual: interface extend
impure virtual: interface extand and default implementation
- if no same name, using default implementation
- if has same name, hide the default implementation
non-virtual: implementation extend
- will hide implementation if the same name in child

Alternative virtual

template method
- template method has implementation extend, which can be final
- call virtual method which has default implementation, also can be overriden
strategy pattern
- using function ptr
- using std::function

Never redefine non-virtual from base class

base class implementation will be hiden
also non-virtual function is statically bound, which means, using base class ptr or reference will call the base version

Never redefine default parameters

virtual function is dynamically bound, while default parameter is statically bound
which means, virtual function is about the dynamical type, and default parameter is about static type
alternative implementation: template method
- non-virtual function to override default parameter
- call virtuall function to core implementation

Composition means has-a or implement-of

composition is different from public inheritance
- has-a
- implement-of: using public interface to implement new feature
  - ex, using list to implement set

Private inheritance means implement-of

when implement-of is using protected member, consider private inheritance

Multiple inheritance

virtual inheritance to handle diamond inheritance
only use multiple inheritance when implement-of
- multiple implement interface class
- multiple implement private inheritance

Template & Generic Programming

Implicit interface and compile-time polymoriphism

class inheritance and class template both support interface and ploymoriphism
class inheritance is explicit support
class template is implicit support

Using typename

using typename means it is a type not others
- typename Class::Type_t

Templatized base class

using template class as base class:
- template class Child: public Base
call function in base tempalte class space:
- just simple func() won’t work
- force this->func()
- force using Base::func
- force Base::func()

Template Parameter

non-type template parameter change to function parameter, to reduce code size
type template parameter using shared implementation to reduce code size
- in base class
- in non-member function

Member function template

template
Class(U)
- used in construction
- used in copy construction or operator=
  - default version is still needed

Non-member function to cast

member function can not conversion the caller’s type, while non-member function can

Traits class

using traits class to only handle types in different template specializing

Meta programming

get result when compiling
- make sure unit is aligned
- simplify expression computation
- implement strategy pattern

New & Delete

new handler
- when operator new failed of OOM, will call new handler
- using set_new_handler to set, usually return abort or exit
new (std::throw)
- common new throw bad_alloc when failed
- nonthrow-new return nullptr when failled
- though opreator new wont throw, constructor will throw exception either
why self-defined operator new and delete
- for debug or stats
- for long-term program or short-term program, big-block or tiny-block to accelate
  - which standard new and delete are for common use
self-defined operator new: static void* operator new (std::size_t) throw (std::bad_alloc);
- handle size is not equal to class size
- allocate memory in a while loop
- call new_handler when failed
- return size-1 when ask for size-0 memory
self-defined operator delete: static void operator delete (void*) throw();
- handle size is not equal to class size
self-defined placement new and delete
- static void* operator new (std::size_t, void*) throw (std::bad_alloc);
- static void operator delete (void*, void*) throw();
- self-define both at the same time
do not overwrite the standard new and delete
- explict define standard new and delete in base class
- add using BaseClass:: operator new/delete in child class if you want to use the standard one