C++

It can achieve effect of virtual function but without the cost of dynamic polymorphism.

  template <class T> struct Base {
    void implementation() {
      static_cast<T*>(this)->implementation();
    }
    static void static_func() {
      T::static_sub_func();
    }
  };
  struct Derived : public Base<Derived> {
    void implementation();
    static void static_sub_func();
  };

counter<X> and counter<Y> are different class, so the counters are separate for X and Y.

  template <typename T> struct counter {
    static int objects_created;
    static int objects_alive;
    counter() {
      ++objects_created;
      ++objects_alive;
   }
    counter(const counter&) {
      ++objects_created;
      ++objects_alive;
    }
  protected:
    ~counter() {
      -- objects_alive;
    }
  };
  template <typename T> int counter<T>::objects_created(0);
  template <typename T> int counter<T>::objects_alive(0);

  class X : counter<X> {};
  class Y : counter<Y> {};

When using polymorphism, one sometimes needs to create copies of objects by the base class pointer. So a clone virtual function is created in the base class, and defined in every derived classes. To avoid duplication in the derived class:

  class Shape {
  public:
    virtual ~Shape() {};
    virtual Shape *clone() const = 0;
  };
  // CRTP class
  template <typename Derived> class Shape_CRTP : public Shape {
  public:
    virtual Shape *clone() const {
      return new Derived(static_cast<Derived const&>(*this));
    }
  };
  // ensure correct usage
  #define Derive_Shape_CRTP(Type) class Type: public Shape_CRTP(Type)
  // usage
  Derive_Shape_CRTP(Square) {};
  Derive_Shape_CRTP(Circle) {};

If you don't write, the compiler will generate:

• a copy constructor
• a copy assignment operator
• a destructor
• a default constructor(if you defined no constructors at all)

 class A {
 public:
   A() {...} // default
   A(const A& rhs) {...} // copy
   ~A() {...} // destructor
   A& operator=(const A& rhs) {...} // copy assignment operator
 };

But they are generated only if they are needed. For the operator=, compiler will generate it iff:

• resulting code is legal
• reasonable to make sense

e.g.

 class A {
 private:
   std::string &name;
   const int num;
 };

compiler will reject to generate operator= because when doing assignment, should the reference be modified? C++ doesn't allow make a reference refer to another object. Should the referred string be modified? It will affect other objects! It is not legal to modify a const member either. If you want to support copy assignment in the class containing reference or const, you must define it yourself.

link time solution: Declare the copy constructor and the copy assignment operator private. So that compiler will not generate, outside can not see them. However, member and friend functions can still call them.

compile time solution: Inheritate from Uncopyable class who declared but didn't define the copy constructor and assginment operator. This works because the compiler will try to generate copy constructor and copy assignment when anybody tries to copy it, but will of course fail. It will give error says no instance of copy instructor implemented, in other word you can't pass compilation.

 class Uncopyable {
 protected:
   Uncopyable() {}
   ~Uncopyable() {}
 private:
   Uncopyable(const Uncopyable&);
   Uncopyable& operator=(const Uncopyable&);
 };
 class A : private Uncopyable {}

   class A {
   public:
     A();
     A(const A& rhs); // copy constructor
     A& operator=(const A& rhs) { // copy assignment operator
       return *this; // should return *this
     }
   };

   A a1; // default constructor
   A a2(a1); // copy constructor
   a1 = a2; // copy assignment operator
   A a3 = a2; // copy constructor

if new object is being defined, a constructor has to be called. That's why a3 is not calling a copy assignment operator.

copy constructor matters because it defines how an object is passed by value. In particular, pass-by-value means "call the copy constructor".

To create an exception safe implementation of overloaded assignment operator. The copy assignment opeartor implementation can cause two kinds of unsafety:

• self-assignment unsafe
• exception unsafe

Self-assignment should be properly handled. It can appear often, e.g. a[i] = a[j]; in the case i=j, *px = *py;.

The following code explain the two kinds of unsafe.

• self-assignment unsafe: rhs.pa is already deleted if rhs == this
• exception unsafe: if exception happens during new, pa will contains a pointer to a deleted A.

    class A {};
    class B {
     private:
      A * pa;
    };
    B& B::operator=(const B& rhs) {
      if (this == &rhs) return * this; // get rid of self-assignment unsafe
      delete pa;
      pa = new A(* rhs.pa);
      return * this;
    }

According to https://en.wikibooks.org/wiki/More_C++_Idioms/Copy-and-swap, the copy and swap is:

Create a temporary and swap idiom acquires new resource before it forfeits its current resource. To acquire the new resource, it uses RAII idiom. If the acquisition of the new resource is successful, it exchanges the resources using the non-throwing swap idiom. Finally, the old resource is released as a side effect of using RAII in the first step.

The code follows:

    class B {
      // use std::swap?
      void swap(B& rhs) {
        std::swap(xx,rhs.xx);
      }
    };
    // v1: explicitly create new. BAD
    B& B::operator=(const B& rhs) {
      B tmp(rhs);
      swap(tmp);
      return * this;
    }
    // v2: use pass-by-value as temporary value. GOOD.
    // better optimization
    B& B::operator=(B rhs) {
      swap(rhs);
      return * this;
    }

Move constructor enables you to implement move semantics, which can significantly improve the performance of your applications. Move semantics enables you to write code that transfers resources (such as dynamically allocated memory) from one object to another. Move semantics works because it enables resources to be transferred from temporary objects that cannot be referenced elsewhere in the program.

To implement move semantics, you typically provide a move constructor, and optionally a move assignment operator (operator=), to your class. Copy and assignment operations whose sources are rvalues then automatically take advantage of move semantics. Reference: Move Constructors and Move Assignment Operators from Microsoft.

Move Constructor Example:

  // Rvalue Reference
  MemoryBlock(MemoryBlock&& other) : _data(nullptr) , _length(0) {
    // copy
    _data = other._data;
    _length = other._length;
    // set source object fields to default, to avoid multiple free
    other._data = nullptr;
    other._length = 0;
  }

Move Assignment Operator Example:

  MemoryBlock& operator=(MemoryBlock&& other) {
    // avoid self-assignment
    if (this != &other) {
      // Free the existing resource.
      delete[] _data;
      // Copy the data pointer and its length from the 
      // source object.
      _data = other._data;
      _length = other._length;
      // Release the data pointer from the source object so that
      // the destructor does not free the memory multiple times.
      other._data = nullptr;
      other._length = 0;
    }
    return *this;
  }

The explicit prevents the class from being used to perform implicit type conversions, though they may still be used for explicit type conversions. Always declare it explicit unless you have a good reason for allowing a constructor to be used for implicit type conversions.

 class A {
 public:
   explicit A(int x=0, bool b=true);
   explicit A(char c); // non-default can also have explicit
 };
 void func(A a);

 A a1;
 func(a1); // ok
 A a2(20); // ok
 func(20); // error, cannot convert int to A implicitly
 func(A(20)); // use B constructor to explicit convert

• polymorphic base classes should declare virtual destructors. If a class has virtual functions, it should have virtual destructor
• Classes should not have virtual destructor if it is not designed to be
  • base class, or
  • used polymorphically

Factory Function: a function that returns a base class pointer to a newly-created derived class object.

 class TimeKeeper {
 public:
   TimeKeeper();
   virtual ~TimeKeeper(); // must have the virtual, or disaster
 };
 class AtomicClock : public TimeKeeper {};
 class WaterClock : public TimeKeeper {};
 class WristWatch : public TimeKeeper {};

 TimeKeeper *getTimeKeeper(); // can return any one

 TimeKeeper *ptk = getTimeKeeper();
 // ...
 delete ptk;

If no virtual, the delete ptk will call the destructor of TimeKeeper, so the AtomicClock part of the struct will be never destroyed.

But do not declare every destructor virtual: If a class does not contain virtual functions, it is not meant to be used as a base class. DO NOT use virtual destructor for it. Because:

• virtual requires the objects carry information that can be used at runtime to determine which virtual function to invoke. It will increase the size.
• it is not the same as the counterpart in C, not portable.

Never call virtual functions during construction or destruction. Because during base construction, virtual functions never go down into the derived class.

Without virtual you get early binding. Which implementation of the method is used gets decided at compile time based on the type of the pointer that you call through.

With virtual you get late binding. Which implementation of the method is used gets decided at run time based on the type of the pointed-to object - what it was originally constructed as. This is not necessarily what you'd think based on the type of the pointer that points to that object.

 class Base
 {
 public:
   void Method1 ()  {  std::cout << "Base::Method1" << std::endl;  }
   virtual void Method2 ()  {  std::cout << "Base::Method2" << std::endl;  }
 };

 class Derived : public Base
 {
 public:
   void Method1 ()  {  std::cout << "Derived::Method1" << std::endl;  }
   void Method2 ()  {  std::cout << "Derived::Method2" << std::endl;  }
 };

 Base* obj = new Derived ();
 //  Note - constructed as Derived, but pointer stored as Base*

 obj->Method1 ();  //  Prints "Base::Method1"
 obj->Method2 ();  //  Prints "Derived::Method2"

• virtual function can be overriden
• the pure virtual must be implemented in non-abstract class

"is-a" relation.

Private inheritance means "is-implemented-in-terms-of". Private inheritance means nothing during software design, only during software implementation. Means Derived objects are implemented in terms of Base objects, nothing more.

Composition means either "has-a" or "is-implementated-in-terms-of".

 class Base {
 private:
   int x;
 public:
   virtual void mf1() = 0;
   virtual void mf1(int);

   virtual void mf2();

   void mf3();
   void mf3(double);
 };
 class Derived : public Base {
 public:
   // using Base::mf1; // making all things in Base named mf1 and mf3
   // using Base::mf3; // visible and public in Derived's scope
   virtual void mf2() {  // forwarding function
     Base::mf1();
   }
   virtual void mf1();
   void mf3();
   void mf4();
 };

the mf3 in Derived will hide both of the mf3 in Base. The rationale behind this behavior is that it prevents you from accidentally inheriting overloads from distant base classes when you create a new derived class in a library or application framework.

• using declarations
• forwarding functions

The Curiously Recurring Template Pattern (CRTP) is an idiom in C++ in which a class X derives from a class template instantiation using X itself as template argument¹. It is also known as F-bound polymorphism\cite{canning1989f}. One of the use case of CRTP is static polymorphism. Generally speaking, I have a base class and some derived class, and I want to have a ~~static virtual'' function that is implemented differently in different subclasses. I think such ~~static virtual function'' does not exist. But we can simulate it.

   template <class T> 
   struct Base {
     void interface() {
       // ...
       static_cast<T*>(this)->implementation();
       // ...
     } 
     static void static_func() {
       // ...
       T::static_sub_func();
       // ...
     }
   };

   struct Derived : Base<Derived> {
     void implementation();
     static void static_sub_func();
   };

Putting all convenience functions in multiple header files, but one namespace.

webbrowser.h

 namespace WebBrowserStuff {
   class WebBrowser {...};
   void clearBrowser(WebBrowser& wb);
   // ...
 }

webbrowserbookmarks.h

 namespace WebBrowserStuff {
   // bookmark related functions
 }

private and protected member cannot be accessed outside the class, except friends.

 class A {
 public:
   friend A func(A a); // declare friend
 private:
   int m;
 };
 A func(A& a) {
   A res;
   res.m = a.m; // access both param and return value
   return res;
 }

a class whose member functions can access private and protected member of another class.

 class Rectangle {
   int width, height;
 public:
   int area () {}
   void convert (Square a) {
     width = a.side; // access side in Square
     height = a.side;
   }
 };

 class Square {
   friend class Rectangle; // friend declaration
 private:
   int side;
 public:
   Square (int a) : side(a) {}
 };

Pass-by-value has two problems. Apart from copy problem, there's also a slicing problem, i.e. when a derived class object is passed by value as a base class object, the base class constructor is called, thus the part of the subclass outside the base class will be sliced away.

Also do NOT just pass by value because the struct seems to be small.

• it can be large, by inheritance
• the copy constructor may be costly: a object contain little more than a pointer, but the constructor will copy everything they point to.
• some compiler treat built-in type and structure differently. Some will refuse to put a struct that only contains a double into register, but it will surely put a double into register.

So some situation pass by value is more efficient though:

• built-in type(e.g. int)
• iterators and function objects in STL, they are designed to pass by value

On the other hand, reference is often implemented as pointer. However, there're situations where you have no way but to return a value. Return a stack local variable as a reference does not make sense becasue the variable will not exist outside the function. When you return a heap variable, be careful. E.g. in a operator* method, return a heap variable is a disaster. w = x * y * z; the result of x*y will never be free-d.

template <class T>
typename remove_reference<T>::type&& move (T&& arg) noexcept;

template <class T> void swap (T& a, T& b)
{
  T c(std::move(a)); a=std::move(b); b=std::move(c);
}
template <class T, size_t N> void swap (T &a[N], T &b[N])
{
  for (size_t i = 0; i<N; ++i) swap (a[i],b[i]);
}

Example

// move takes an object, invalidate it, and return the rvalue.
std::string bar = "bar-string";
myvector.push_back (std::move(bar));
// Now bar is valid but has no valid content, while the vector contains the string.

Perfect forwarding reduces the need for overloaded functions and helps avoid the forwarding problem. The forwarding problem can occur when you write a generic function that takes references as its parameters and it passes (or forwards) these parameters to another function. For example, if the generic function takes a parameter of type const T&, then the called function cannot modify the value of that parameter. If the generic function takes a parameter of type T&, then the function cannot be called by using an rvalue (such as a temporary object or integer literal).

Ordinarily, to solve this problem, you must provide overloaded versions of the generic function that take both T& and const T& for each of its parameters. As a result, the number of overloaded functions increases exponentially with the number of parameters. (For instance the following code, to write a generic factory function, we need to try all combination of const T& and T& for every type pair of W,X,Y,Z). Rvalue references enable you to write one version of a function that accepts arbitrary arguments and forwards them to another function as if the other function had been called directly.

For example, following code

  struct W {
    W(int&, int&) {}
  };
  struct X {
    X(const int&, int&) {}
  };
  struct Y {
    Y(int&, const int&) {}
  };
  struct Z {
    Z(const int&, const int&) {}
  };

  // Version 1
  template <typename T, typename A1, typename A2>
  T* factory(A1& a1, A2& a2) {
    return new T(a1, a2);
  }
  int a = 4, b = 5;
  W* pw = factory<W>(a, b);
  Z* pz = factory<Z>(2, 2); // error
  // Version 2: using R reference
  template <typename T, typename A1, typename A2>
  T* factory(A1&& a1, A2&& a2) {
    return new T(std::forward<A1>(a1), std::forward<A2>(a2));
  }
  Z* pz = factory<Z>(2, 2); // correct

std::forward function forwards the parameters of the factory function to the constructor of the template class.

• The compiler treats a named rvalue reference as an lvalue and an unnamed rvalue reference as an rvalue.
• You can cast an lvalue to an rvalue reference. static_cast<MemoryBlock&&>(block)

For detail, refer to Rvalue Reference by Microsoft.

• Full declaration:

 [ capture-list ] ( params ) mutable(optional) exception attribute -> ret { body }

• Declaration of a const lambda: the objects captured by copy cannot be modified.

 [ capture-list ] ( params ) -> ret { body }

for example

 []()->int { return 2; }

• Omitted trailing-return-type

 [ capture-list ] ( params ) { body }

if the body contains nothing but a single return statement, the return type is that expression's type. Otherwise return type is void.

• Omitted parameter list

take no parameters.

 [ capture-list ] { body }

• mutable: allows body to modify the parameters captured by copy, and to call their non-const member functions
• exception: provides the exception specification or the noexcept clause for operator() of the closure type
• attribute: provides the attribute specification for operator() of the closure type
• capture-list: a comma-separated list of zero or more captures
  • [a,&b]: where a is captured by value and b is captured by reference.
  • [this]: captures the this pointer by value
  • [&]: captures all automatic variables odr-used in the body of the lambda by reference
  • [=]: captures all automatic variables odr-used in the body of the lambda by value
  • []: captures nothing

This is deprecated. In the declaration of a function, you can add a throw keyword and the type of exception in parenthesis. Throw is a specifier, and is part of the function type.

double myfunction (char param) throw (int);

If the function throws exception other than int, the function std::unexpected is called. Function without throw specifier will never call std::unexpected, and do the normal exception handling. If here there's no type in the parenthesis, it means the function should not throw any exception.

noexcept is the current in use one. If no argument provided, it is same as noexcept(true). If argument is provided, it is evaluated and if it evaluates to true, it means this function is not throwing any exception. Otherwise the function is potentially throwing. throw () is same as noexcept(true) but is deprecated.

Use when you want to define a different implementation for a template when a specific type is passed as template parameter.

The syntax is this: put an empty inside the brackets, and put a <char> after the class name. When instantiate this class with char, it will use the specialized one.

template <class T> class mycontainer { ... };
template <> class mycontainer <char> { ... };

So only have the second form is not valid.

The parameter can not just be a type name, but also a regular type.

template <class T, int N>
class mysequence {
    T memblock [N];
  public:
    void setmember (int x, T value);
    T getmember (int x);
};

It can have default values:

template <class T=char, int N=10> class mysequence {..};

Then the following calls are equivalent:

mysequence<> myseq;
mysequence<char,10> myseq;

See https://isocpp.org/wiki/faq/templates#templates-defn-vs-decl

The compiler must see two things at the same time in order to instantiate a template class. Because the instantiated template class are generated by the compiler.

• all the template implementation
• the type used to instantiate the template

For example:

foo.h

template<typename T>
class Foo {
public:
  void f();
  void g();
  void h();
};
template<typename T> inline void Foo<T>::f() {}

foo.cpp

#include <iostream>
#include "foo.h"
template<typename T> void Foo<T>::g() {
  std::cout << "Foo<T>::g()\n";
}
template<typename T> void Foo<T>::h() {
  std::cout << "Foo<T>::h()\n";
}

main.cpp

#include "foo.h"
int main() {
  Foo<int> x;
  x.f();
  x.g();
  x.h();
}

The link will generate error that cannot find g and h definition. Of course moving the definition in foo.cpp to foo.h can solve the problem, but it will make the header file too big.

Another way: put template class Foo<int>; at the end of foo.cpp, thus compiler can see the Foo<int> and implementation at the same time.

You can also have a foo-impl.cpp for adding this, but it should include foo.cpp

foo-impl.cpp

#include "foo.cpp"
template class Foo<int>;

 #include <iostream>
 int price;
 cin>>price;

If the input is not integer, the program will continue without setting price's value. Then if a is used afterwards, undefined behavior.

To add a validation process, we need to use stringstream:

 #include <sstream>
 string mystr;
 getline(cin, mystr);
 stringstream ss = stringstream(mystr);
 // validate ss
 int price;
 ss >> price;

Always use getline instead of cin directly

 while(getline(cin, line)) {;}
 while(getline(fs, line)) {;}

Objects that act like functions. Such objects come from classes that overload operator().

 auto g = bind(f, a, b, _2, c, _1);

此后，调用 g(-1,-2) 等价于调用f，并把 _1 换成 -1, _2 换成 -2.

适用于 string, vector, deque, array

c.at(n) 返回下表为~n~的元素的引用。如果下标越界，可以抛出 out_of_range 异常。

std::make_pair

 template <class T1,class T2>
 pair<T1,T2> make_pair (T1 x, T2 y)
 {
   return ( pair<T1,T2>(x,y) );
 }

for example:

 std::make_pair("hello", "world");

equals to:

 std::pair<string, string>("hello", "world");

1. prefer the compiler to preprocessor,

the define may never be seen by compiler, thus less meaningful debug information, less optimization.

1. #define don't respect scope.

The change of a single class can lead to a large amount of file to recompile, because:

• Inheritance
• Use another class inside a class

C++ standard library is guaranteed to have 18 standard headers from C. Two type of names: <cxxx> and <xxx.h>

• <cxxx>: provide in the std namespace only
• <xxx.h>: make them available in both std and global. Deprecated

• using-directive: using namespace std;. Do not use.
• using-declaration: using std::cout;. Can be used just as a statement, e.g. in a function.

Declare near the first use.

If you don't have enough information to initialize an object until the middle of the code, create it there. Don't initialize it to empty and reassign it later, because performance.

• A class Fred~’s assignment operator should return ~*this as a Fred& (allows chaining of assignments)
• A class with any virtual functions ought to have a virtual destructor
• A class with any of the following generally needs all 5
  • destructor
  • copy assignment operator
  • copy constructor
  • move assignment operator
  • move constructor
• A class Fred~’s copy constructor and assignment operator should have const in the parameter: respectively ~Fred::Fred(const Fred&) and Fred& Fred::operator= (const Fred&)
• When initializing an object’s member objects in the constructor, always use initialization lists rather than assignment. 3x performance.
• Assignment operators should make sure that self assignment does nothing, otherwise you may have a disaster

abbr evthng n sght, usng vry shrt idntfr nms

The common idiom of "prohibiting copying" can now be expressed directly:

  class X {
    // ...
    X& operator=(const X&) = delete;        // Disallow copying
    X(const X&) = delete;
  };

Conversely, we can also say explicitly that we want to default copy behavior:

  class Y {
    // ...
    Y& operator=(const Y&) = default;       // default copy semantics
    Y(const Y&) = default;
  };

The "default" mechanism can be used for any function that has a default. The "delete" mechanism can be used for any function. But, just use them on copy constructor and assignment operator.

Reference: http://www.stroustrup.com/C++11FAQ.html#default

the middle of the conditional operator (between ? and :) is parsed as if parenthesized: its precedence relative to ?: is ignored

The operand of sizeof can't be a C-style type cast: the expression sizeof (int) * p is unambiguously interpreted as (sizeof(int)) * p, but not sizeof((int)*p).