1.1.16.1 Interface

• For function interface design, there are three basic rules here:
  1. Never return reference or pointer to a local object in a function.
  2. Never return a dereferenced point to a local new object.
  3. Never return reference or pointer to a private or protected member data.
• Nesting a class does not create a class member of another class. Instead, it defines a type that is known just locally to the class that contains the nested class declaration. A good example is Class queue nest Class node, because node is just used inside the Class Queue.
• Virtual function must be member, operator» and « are never be members, or It maybe friend. Only non-member functions get type conversions on their left-most argument. In the previous example, If you want to use support 2* obj, You need make operator * to be non member function. Detail can be seen in effective c++.
• Keep in mind that only a class declaration can decide which functions are friends, so the class declaration still controls which functions access private data.
• pretect keyword don’t use very often, it just used in inheritance context, you should use private keyword first if you real want to have good Encapsulation
• In C++ primer p653, you can see a good example class interface. You should remember it as a basic pattern. If you use new allocate memory inside of your class, you should define: copy ctor, assignment operator and destructor, move copy ctor, and move assignment.
  public: 
  String();  //default constructor 
  String(const char *a ); // specify constructor 
   
  String (const String &);  //copy ctor 
  String (String && other); //move copy ctor 
   
  String& operator=(const String &); //assignment 
  String& operator=(String&& other); //move assignment 
   
  ~String();  //usually, you should have these Seven member 
                 //functions if you use new inside your class. 
   
  friend ostream& operator<<(ostream & os, const String & st); 
  friend istream& operator>>(istream & is, String &st); 
   
  private: 
  const static int NUM= 1000; // const used inside of this class. 
  String& operator=(const char*a); // option. 
  ---------------------------------------------------- 
  // in .cpp file 
  String s; 
  s = "aaa"  //two actions 
  String s("aaa");   //one actions 
  String s{"aaa"};  // new feature in c++11 
  String s={"aaa"}; // same as previous one 
   
  String str; char temp[40]; 
  str= temp // make it more efficient
• String& operator=(const char*a); is option, why it make str=temp more efficient, see C++ Primer P652
• Friend has three categories:
  1. Friend Class: just as TV and RemoteControl, you can declare RemoteControl a friend class inside TV.
  2. Friend Member functions: You can select some member functions to be friend of another class, In this way, you need forward declaration. When you write class TV; It doesn’t define a TV class, it just tell compile, TV is a class, definition can be done later.
  3. Common Friend method, a good example is overload operator "«"