1.1.2.3 Translation unit

• Each .cpp is a translation unit. Basically, you should put each class into a single .cpp file, and make sure each .cpp file has a corresponding .h file. If two class are highly correlated, they maybe put in the same .cpp file.
• A translation unit roughly consists of a source file after it has been processed by the C preprocessor, meaning that header files listed in #include directives are literally included, sections of code within #ifdef may be included, and macros have been expanded.
• $ gcc -E -dM file.c &x#21B2; will output only result from preprocessor and all defined macros.
• If you just want a function or variable visible to only current translation unit. You can declare it as static. Or you can use unnamed namespace. You don’t need to put it into a header file. But in C++, you have to declare function and variable before you use them. Different with C language, In C language, compiler will guess a function prototype from it’s usage, It’s not good sometimes.
• C/C++ is separate compilation. If you need to use a function or variable in two different files, you should put them in the global.h file and include them when necessary. (add extern keyword before variable name). It will keep declaration just once, DO NOT copy declaration to the other positions in the other .cpp file. It will lead to many duplication, it’s bad smell of code.
• A better suggestion is to have a single global.h file for a complex system. Then put some common type, defined type, constant and global function in this single global.h file. So it will help to reduce duplication, just keep once appearance.
• Three rules about header file:
  1. Use #pragma once to add include guard, It’s not standard, but It has been supported by many compiler. Including g++, clang and MSVC.
  2. Put your local/private header file in front of system header file. Why? There are two advantage, 1) You can know what header file should be included, It’s helpful to achieve the goal of demand 2. 2) Sometimes, if you have you own fun with same name as system or library, It can give you a compile error; Below example will give you a compile error. But if you put <cmath> before myHead.h. Then, main will use acos in cmath, and your acos will be override.
     #include "myHead.h"  //double acos(double) 
     #include <cmath> 
     main{ 
     acos(0.5); 
     }
  3. You will need to put he minimal set of #include statements that are needed to make the header compilable when your local/private header is included on the first place. It will make your header file self-sufficient.
• In .h file, you can include template and inline function. In fact, you have to put template into .h file. and put a semicolon in the end of head file is good suggestion. You also need semicolon after declare class. In .cpp file, no semicolon after each function definition.
• About pimpl, you need to know below:
  1. In you .h file, you use Foo* p or Foo& rp; You don’t need include Foo.h file. you can use forward declaration.
     class Foo; 
     Foo* p;
  2. Base on previous forward declaration, you can use "Pimpl" idiom.
     // widget.h file 
     class Widget { // still in header "widget.h" 
     private: 
     struct Impl; // declare implementation struct 
     std::unique_ptr<Impl> pImpl; 
     }; 
      
     //widget.cpp file 
     #include "Foo.h"  // just include Foo.h in .cpp file. 
     struct Widget::Impl { 
     Foo f1; 
     Gadget g1; 
     };
  3. Pimpl Idiom is one of std::unique_ptrs most common use cases. But different with raw pointer, you need to declare or implement some special member functions, such as dtor ctor and move ctor. Explanation can be seen in "effective modern C++ item 22"
     // widget.h file 
     class Widget { // still in header "widget.h" 
      
     Widget(Widget&& rhs); // declarations 
     Widget& operator=(Widget&& rhs); // only 
     ____________________________________Widget::~Widget() 
     Widget(const Widget& rhs); // declarations 
     Widget& operator=(const Widget& rhs); // only 
      
     private: 
     struct Impl; // declare implementation struct 
     std::unique_ptr<Impl> pImpl; 
     }; 
      
     //widget.cpp file 
     #include "Foo.h"  // just include Foo.h in .cpp file. 
      
     Widget::~Widget() = default; // as before 
     Widget::Widget(Widget&& rhs) = default; // definitions 
     Widget& Widget::operator=(Widget&& rhs) = default; 
     Widget::Widget(const Widget& rhs) // copy ctor 
     : pImpl(std::make_unique<Impl>(*rhs.pImpl)) 
     {} 
      
     Widget& Widget::operator=(const Widget& rhs) { 
     *pImpl = *rhs.pImpl; 
     return *this; 
     }