1.1.1.3 Code Convention

• Use static_assert to test some compile-time boolean conditions. It support a message parameter. It doesn’t need to build execution application. It will stop when you are compiling.
  static_assert(sizeof(int) > 8, "int␣is␣too␣small");
• If you frequently use dynamic_cast, It can be a sign that your base class offer too little functionality.
• For forward function, 1) prefer to use reference 2) don’t inline f function.
  bool f( X x ){ 
  return g( x ); 
  }
• Use const as many as possible.
• Declare variables as locally as possible and minimize global data.
• Avoid macro, use inline function; Avoid magic numbers, instead of using const and enum
• Format lambdas like blocks of dode.
  int cutoff = 7; 
  std::find(foo.begin(),foo.end(),[&](const Foo &a, ) ->bool{ 
      return a.blah<cutoff //use reference to get local var 
  });
• Always initialize variables. Some suggestions about initialization:
  1. Manually initialize non-member objects of built-in types. including a pointer.
  2. Use member initialization list to initialize all parts of an object.
  3. The initialization order uncertainty that afflicts non-local static objects defined in separate translation units.
     1. The questions is below:
        #include "x.h" // File x.cpp 
        X x; 
        //x maybe initialize before y or after y 
         
        #include "y.h" // File y.cpp 
        Y y; 
        Y::Y(){ //here x maybe not be constructed 
          x.goBowling(); 
        }
     2. How to resolve: build Singleton class
        #include "x.h"  // File x.cpp 
        X& getX(){ 
          static X x; 
          return x; 
          __________________________________________________________________________________________//another implementation. 
          //static X* px = new X(); 
          //return *px; 
        } 
         
        #include "y.h" // File y.cpp 
        Y y; 
        Y::Y(){ //here x maybe not construct 
          ____________getX().goBowling(); 
        }
     3. Formally, C++ initializes such variables in three phases: 1. Zero initialization 2. Static initialization 3. Dynamic initialization
        int g0;  //zero initialization 
        int g1 = 42;    //  static initialization 
        extern int f(); 
        int g2 = f();   //  dynamic initialization
        int a = f(); // a exists just to call f 
        int x = 22; 
        int f() { 
            ++x; 
            return 123; // unimportant arbitrary number 
        } 
        // x equals to 23.  because static initialization 
        is earlier than dynamic initialization
• Pay attention to the global object are initialized in right order. Because the order can be arranged in the same translation unit, but not between translation units, see effective c++ Item 47. So we don’t encourage you to use global object unless it’s very necessary.
• Use _FILE_ and _LINE_ to capture the current file name and line number. I think that assert use this kind of macro inside.
• Use const replace #define to define global constants. Use static const to define class constant. (const means that it will not change, so I don’t need keep multi copy in multi objs, so I use static.)
• Use more typedef to simplify Complicated Type expressions, It’s helpful especially in STL
  typedef std::map< int, int > IntMap; 
  typedef IntMap::const_iterator IntMapConstIter; 
  for( IntMapConstIter it = layout.begin(); 
                              it != layout.end(); ++it ) { 
   
  typedef int(*CB)(int, const char*); //C++11 use function<> 
  CB callBack;  //decare a functions pointer. 
   
  int sort(int, const char*){..} 
  callBack = sort; // & operator is optional here!
• Using alias(C++11) is better than typedef.
  using UPtrMapSS = 
  std::unique_ptr<std::unordered_map<std::string, int>>; 
   
  using CB = int(*)(int, const char*);
• Create a zero-valued enumerator to indicate an invalid or default state and make it the first one.
• Declare all member variables private. Then use getter and setter functions to access them.
• Don’t use multi-thread unless you really need it. Simultaneously respond to many events. Just remember, synchronization has high cost.
  1. A web server.
  2. Interface and working thread.
  3. Take advantage of with multiple processor.
• Use Early Exits to simplify code.
  if(IsValid){   //bad style 
     do something; 
  } else{ 
    return; 
  } 
   
  if(!IsValid)  // A better style is 
    return; 
  ..do something here.
• Turn Predicate Loop into Predicate Function. It make you code clean and easy to understand.
  for(v.begin....){   /bad style 
    if(it->IsSth){ 
        flag = true; break; 
    } 
  } 
  if(flag){...} 
   
  // A better style is define isHasSth() return bool. 
  if(isHasSth()){...}
• Use assert more in your project. You don’t need to include file name and line number in the string. assert will output these hint messages.
  #include<cassert> 
  assert(index>=0 && "␣index␣is␣negative"); 
  //Assertion failed: expression, file name, line num
• If you don’t modify container inside loop, don’t need to evaluate end() every time through for loop. Please remember below code block. Just remember auto i,e ++i
  //g++ -std=c++11 
  vector<int> con={1,2,3} //list initializer for(auto i = con.begin, e = con.end();i!=e; 
  ++i){ 
                ........... 
  }
• The C++11 standard (Âğ 23.2.1) mandates that end has O(1) complexity, so previous item has no efficiency meaning in C++11.
• A range-based for loop is introduced in C++11. Use auto& to aoid copying the each element. Below are highly recommended when yo use STL container.
  //g++ -std=c++11 
  for(const auto &val : Container) { read(val)}; 
  for(auto val : Container) { change(val); save(val)}; 
   
  //make sure Container contain pointer 
  for(auto *ptr: Container){ ptr->change();} 
  for(const auto *ptr: Container){ ptr->read();}
• The range-based version is for: You want to do something with every element in the container, without mutating the container(insert or erase). If you want to mutate the container, Follow idea introduced in Container–Erasure section below.
  1. For any container, you can NOT mutating container by calling insert or erase inside loop.
  2. For a sequential container, you can use range-based version change element.
  3. For an associate container, only visit each element.
• Common function interface: From here: you can see "const" only used in pointer or reference type. You should use more const in your projects.

  	read	write
  primitive (char, int, float)	pass value	pointer or reference
  class, array, structure	const pointer or reference	pointer or reference

• Prefer Preincrement (++i), especially in for loop. When you use ++i or i++ inside expression, there are differences. Otherwise, there is no differences.
  for(int i = 0;i<10; ++i) 
  j=++i; // j = i+1; 
  j=i++; //j = i;  i=i+1; 
  ++*p;  //++(*p) ; 
  *++p; //*(++p);
• How to understand *p++?
  1. Precedence of prefix ++ and * is same. Associativity of both is right to left.
  2. Precedence of postfix ++ is higher than both * and prefix ++. Associativity of postfix ++ is left to right.
  3. Prefix and postfix are both syntax sugar, in order to reduce typing. But prefix represents one statement, postfix means two statements;
  ++i;  //just like i = i+1 or  i+=1; 
  //when i++ used in expression, treated as two statements; 
  *p++; // *(p++);  *p ; p=p+1; 
   
  while(*p != ’\0’){ 
  p= p+1; 
  } 
  //can be written to 
  while(*p++ != ’\0’)
• Always turn on all warning option in your compiler with -Wall. Once you get warning, Eliminate warning before you go further.
• Sometimes, this warning is what you have to, or If warning comes from a header file you can’t change. You can use #pragma warning compile directive to temporary disable it, then restore it later.
  #pragma warning(push) 
  #pragma warning(disable:4512); 
  #include<not_change.h> 
  #pragma warning(pop) //restore original warning level