• char s[] = "abc"; is const char pointer, it can not be modified.
• char* s = "abc"; is a pointer, it can be modified

void fun(char* arr){
   arr[0] = 'k';
}

// can not modify the const pointer 
char s[] = "abc";
fun(s);
printf("%s", s); // => abc

// modify the pointer
char* s1 = "abc";
fun(s1);
printf("%s", s1); // => kbc

• The length of string is trick.

  char a[20]="ab";
  char b[20]={'a', 'b','\0'};
  char c[]={'a', 'b','\0'};
  char d[]={'a', 'b'};  // ERROR: can be any number
  printf("Length of string a = %ld \n",strlen(a));
  printf("Length of string b = %ld \n",strlen(b));
  printf("Length of string c = %ld \n",strlen(c));
  printf("Length of string d = %ld \n",strlen(d));
  

• reference is like static pointer which points to memory address of variable.

  • You can change the content of memory address. E.g.

    int num = 3;
    int* pt = #
    num = 5;
    printf("num=%d, pt=%d\n", num, *pt);
    

  • Pointer(int *pt) reference(int &ref) and const reference (const int& cref)

    • The content of ref can be changed.
    • The content of cref can not be changed.
    • ref is an alias to num and the content of ref can be modified.
    • cref is an alias to num but the content of cref can not be modifed.

    int num = 3;
    int &ref = num;  // ref is an alias to num
    const int& cref = num;  // cref is an alias to num but the content of num can not be modified via cref
    

• Return a reference if a variable is not local to the function.

int num = 3;
int& test(){
  return num;
}       
test() = 5;
printf("%d", num); // num => 5

Passed by value to a function, it means you only have the copy of the original of variable, you can change the value of variable out side the scope of the function

int fun(int num){
    n = n + 1;
    return n;
}

Pass reference to a function, it means you have access to the read-only memory address of the variable

void fun(int& num){
  num = num + 1;
}
int num = 1;
fun(num);
printf("num=%d", num); => 2

Pass const reference to a function, you can NOT modify the content of the read-only memory address

// NOTE: Compilation error
int fun(const int& num){
     num = num + 100;
     return num;
}

• Get a pointer to the first address of the data. Test Example

class Pt{
public:
    int x;
    int y;
public:
    Pt(){}
    Pt(int x_, int y_){
        x = x_;
        y = y_;
    }
};
std::vector<Pt> vect;
Pt p1;
p1.x = 1;
p1.y = 2;
Pt p2;
p2.x = 3;
p2.y = 4;

vect.push_back(p1);
vect.push_back(p2);
int expected[] = {
    1, 2, 3, 4
};
int* ptrToData = (int*) vect.data();
REQUIRE(compareArray(ptrToData, expected, 4) == true);

• Polygon, Rectangle and Triangle examples.

 class Polygon{
 protected:
 int m;
 int n;
 public:
 Polygon(){
     m = 0;
     n = 0;
 }
 Polygon(int m, int n){
     this -> m = m;
     this -> n = n;
 }
 };

 class Rectangle : public Polygon{
 public:
 Rectangle(){}
 Rectangle(int m, int n){
     Polygon(m, n);
 }
 public:
 double area(){
     return m*n;
 }
 };

 class Triangle : public Polygon{
 public:
 Triangle(){}
 Triangle(int m, int n){
     Polygon(m, n);
 }
 public:
 double area(){
     return m*n/2;
 }
 };


Rectangle* pRect = new Rectangle(1, 2);
cout<<"Rectangle Area"<<pRect->area();
Triangle* pTri = new Triangle(1, 2);
cout<<"Triangle Area"<<pTri->area();

• Virtual function and non virtual function in C++

   class Base{
      public:
      virtual void fun() = 0;
   };
  
  class MyDerived : public virtual Base{
      public:
      virtual void fun(){
        cout<<"MyDerived =>"<<endl;
      }
  };
  
  MyDerived* derivedPt = new MyDerived();
  derivedPt -> fun();
  
  Base* basePt = (MyDerived*)(derivedPt);              // OK
  Base* basePt1 = dynamic_cast<MyDerived*>(derivedPt);  // OK
  basePt -> fun();
  
  delete(derivedPt);
  
  

• What is smart pointer? Smart Pointer
  • Smart pointer is all about ownership, who owns the object
    • Unique pointer only allows ONE ownership
    • Shared pointer allow more than one ownership.
    • Weak pointer has no ownership.
  • Smart pointer can automatically deallocate memory.
• What is unique pointer?
  • As the name implies, make sure exactly only one copy of object exists.
  • Unique pointer can not be copied. \( \Rightarrow \) no use_count() function.
  • You can transfer the pointer to other unique pointer using std::move(), then the origin unique pointer will be deleted.
• What is shared pointer? shared_ptr

  • Shared pointer is based on reference counting and can be used to store and pass reference beyond the current scope.

    class MyClass{
        public:
             MyClass(){}
        public:
             shared_pt<int> fun(){
                 shared_pt<int> pt(new int(9));
                 cout<<"fun pt.use_count()=" <<pt.use_count()<<endl; // pt.use_count() == 1
                 return pt;
             }
    }
    
        // main
        MyClass* cpt = new MyClass();
        shared_pt<int> pt1 = cpt -> fun();
        cout<<"main pt1.use_count()=" << pt1.use_count()<<endl;  // pt1.use_count() == 1
    
    

• What is weak pointer?

• Simple template example.

    template<typename T>
    T fun(T a, T b){
  return a + b;
    }
    template<class T>
    T fun(T a, T b){
      return a + b;
    }
  

• Template class and typename

   template<class T>
   class MyClass{
  public T add(T a, T b){
         return a + b;
  }
   }
  

• Template default type like function has default parameter.

    // function default parameter
    int sum(int a, int b = 0){
  return b == 0 ? a : a + b;
    }
    // template default type
    template<typename U, typename T = int>
    class my_class{
    U x;
    T y;
    };
  

• The difference between struct and union

  • struct allocates memeory for each member variables
  • union share all the memory for all the member variables. (Allocate the maximum memory for all the member variables)

    union UType{
  int x;
  int y;
    };
    UType t;
    t.x = 100;
    printf("x=%d, y=%d\n", t.x, t.y);  // x = 100, y = 100
  

• The difference between struct and class

  • The default access modifier in struct is public.
  • The default access modifier in class is private.

    struct my_struct{
  x;
    }
    my_struct t1;
    std::cout<<t1.x<<endl;
  
    struct my_class{
      public:
  x;
    }
    my_class c1;
    std::cout<<c1.x<<endl;
  

• lvalue and rvalue

• rvalue has no memory address, it is temporary variable in the code.

  int n = 3;        // 3 is rvalue
  int m = 3 + 4;    // 3 + 4 is rvalue
  
  int fun(int n){
    return n + 1;
  }
  
  int t = fun(3);  // the return value of fun(3) is temporary variable
  

• lvalue has memory address. You can access the address with & operator.

  int n = 3;    // n is lvalue
  int m = n;    // m, n is lvalue
  

• Move semantic
• What is double ampersands?
• When you should use?