ref: https://www3.ntu.edu.sg/home/ehchua/programming/cpp/cp1_Basics.html

Type restoring without heap memory allocation (Fastest)

struct DelegateList
{
     int f1(double d) { }
     int f2(double d) { }
};

typedef int (DelegateList::* DelegateType)(double d);

DelegateType d = &DelegateList::f1;
DelegateList list;
int a = (list.*d)(3.14);

Reference

https://www.codeproject.com/Articles/13287/Fast-C-Delegate
https://stackoverflow.com/questions/9568150/what-is-a-c-delegate
http://www.codeproject.com/Articles/7150/Member-Function-Pointers-and-the-Fastest-Possible
http://www.codeproject.com/Articles/11015/The-Impossibly-Fast-C-Delegates
http://www.codeproject.com/Articles/13287/Fast-C-Delegate

  // lvalues:
  //
  int i = 42;
  i = 43; // ok, i is an lvalue
  int* p = &i; // ok, i is an lvalue
  int& foo();
  foo() = 42; // ok, foo() is an lvalue
  int* p1 = &foo(); // ok, foo() is an lvalue

  // rvalues:
  //
  int foobar();
  int j = 0;
  j = foobar(); // ok, foobar() is an rvalue
  int* p2 = &foobar(); // error, cannot take the address of an rvalue
  j = 42; // ok, 42 is an rvalue

http://thbecker.net/articles/rvalue_references/section_01.html

https://www.tutorialdocs.com/article/nodejs-performance.html

Prevent multiple definitions in header files

When there definitions in a header file that can not be made twice, the code below should be used. A header file may be included twice other include files include it, or an included file includes it and the source file includes it again.

To prevent bad effects from a double include, it is common to surround the body in the include file with the following (where MYHEADER_H is replaced by a name that is appropriate for your program).

#ifndef MYHEADER_H
#define MYHEADER_H
	// This will be seen by the compiler only once 
#endif /* MYHEADER_H */

http://www.fredosaurus.com/notes-cpp/preprocessor/ifdef.html

Log Levels

• TRACE - during development, comment before commit to vcs
• DEBUG - run in local machine
• INFO - log all actions by user, system scheduled event
• WARN - potential error
• ERROR - error conditions
• FATAL - critical errors

https://www.scalyr.com/blog/the-10-commandments-of-logging/

Pointers are more powerful than references in the sense that they allow two things that references don’t: nullability and rebinding.

Summary

• References cannot be null and cannot rebind
• std::reference_wrapper cannot be null but can rebind
• Pointers can be null and can rebind (and can do low-level address manipulations)
• boost optional references can be null and can rebind (but are incompatible with std::optional)

https://www.fluentcpp.com/2018/10/02/pointers-references-optional-references-cpp/

http://www.cs.cmu.edu/~gilpin/c++/performance.html

Examples (TL;DR)

Find files containing "foo", and print the line matches in context:

ag foo

Find files containing "foo" in a specific directory:

ag foo path/to/directory

Find files containing "foo", but only list the filenames:

ag -l foo

Find files containing "FOO" case-insensitively, and print only the match, rather than the whole line:

ag -i -o FOO

Find "foo" in files with a name matching "bar"

ag foo -G bar

Find files whose contents match a regular expression:

ag '^ba(r|z)$'

Find files with a name matching "foo":

ag -g foo

https://www.mankier.com/1/ag

My favourite theme: clean

https://ohmyz.sh/
https://www.howtoforge.com/tutorial/how-to-setup-zsh-and-oh-my-zsh-on-linux/