Untitled

BÁO CÁO THỰC TẬP
DAY 1: Gthieu C++, trình biên dịch, code convention
DAY 2: Variables and constant, Primary data type,Array –Pointer, Data structure,Function,Namespace
1. Variables and constant
Variable classification:
- scope: local, global
- Storage class specifier: auto,static,register,extern
Auto variable:
- As default, a variable is a auto variable
  int myVar     <=>   auto int myVar

- Go out of scope once the program exits from the current block

Static variable:
- Allocated when the program starts and is deallocated when the program ends.
- Default value is zero (0)
Register variable: Stored in a machine register if possible. Usually used in “for iterator” for improve performance

Extern variable:
- Specify that the variable is declared in a different file. 

- Compiler will not allocate memory for the variable

- Avoid duplicate declaration

- Share (global) variable for multiple .cpp files
Constant: Variable's value is constant  .To prevent the programmer from modifying
2.Primary data type
New type definition: 
- Use typedef:
 typedef long long ll;
typedef int MyArr_5 [5];
ll var1;
MyArr_5 arr;


sizeof operator: Return size (in byte) of a type, data structure, variable
3. Array –Pointer 
Array:
- C/C++ do not handle out-of-range exception

Pointer: 
- Computer's memory is made up of bytes. Each byte has a number, an address, associated with it.
- When storing a variable, such as int i = 1 
@@@@@@@ VỞ @@@@@

Pointer to pointer:
- Recall that, a pointer variable is a variable.
- To store address of a pointer variable, we use pointer-to-pointer variable. 

Constant pointer vs. pointer to constant:
- Constant pointer:
+ Address of memory stored is constant
+ Value at address which “pointed to” could be changed
+ char char_A = 'A';
char char_B = 'B';
char * const myPtr = &char_A;
myPtr = &char_B;    // error - can't change address of myPtr
- Pointer to constant:
+Value at address which “pointed to” is constant
+Address of memory stored could be changed
+ char char_A = 'A'; 
const char * myPtr = &char_A; 
*myPtr = 'J'; // error - can't change value of *myPtr

Pointer Dynamic allocation:
- Static allocation:
int a = 10;
int array[1000];
+Variable will be allocated in stack  limited size
+Number of elements of array is const
+Can not clean up when they become useless 
- Dynamic allocations
+ User pointer
+ Allocation a block of memory in heap  high capacity
+ Clean up easily


PointerDynamic allocation (cont.)

Pointer-to-pointer dynamic allocation

4.Data structure
Enum: 
-Use for set up collections of named integer constants
-In traditional C way:

Union

Struct:

Data Structure alignment:

Struct - function:

5. Function
Parameter classification: value, rẻence, constant, constant reference, pointer parameter.

Function overloading:

Function Prototype

Extern function

Extern “C”

Pointer to function

Inline function

6.Namespace
- Using namespace
- Namespace – ambiguous call

DAY 3-4: OOP
1.OOP Overview
2. OOp Features
Class and object
- Class, là cách trừu tượng hóa để mô tả một đối tượng. Class là một thiết kế (blueprint), hay mẫu (Prototype) cho các đối tượng có cùng kiểu.

Abstraction: 
Để hiểu abstraction là gì, hãy xem xét ví dụ sau:
Để một chiếc xe hoạt động cần rất nhiều bộ phận bên trong làm việc, nhưng không phải tất cả những thông tin đó đều cần thiết với người lái. Người lái chỉ cần sử dụng những công cụ như: bàn đạp ga, phanh, vô lăng, đèn nháy. Các kỹ thuật phức tạp đều được ẩn khỏi trình điều khiển. Nghĩa là bạn chỉ cần biết cách lái xe, chứ không cần quan tâm những chi tiết về cách thức động cơ hoạt động.
Lấy ví dụ, để di chuyển chiếc xe, người lái chỉ cần vào số, và đạp ga. Không quan tâm đến việc cái xe nó làm việc thế nào. Tương tự với các chức năng khác như phanh, chuyển hướng. 
Và vì nó đúng với tất cả các xe, nên xe ô tô nào cũng có Vô lăng, cần số, bàn đạp ga, phanh, signal, ...

https://vn.got-it.ai/blog/tinh-truu-tuong-trong-oop-va-cac-loai-truu-tuong-ban-can-biet#:~:text=T%C3%ADnh%20tr%E1%BB%ABu%20t%C6%B0%E1%BB%A3ng%20(Abstraction)%20l%C3%A0,T%C3%ADnh%20%C4%91a%20h%C3%ACnh%20(Polymorphism).

Ví dụ ABSTRACTION:

class Car {
public:
   int  PressGasPedal();
   void RotateTheSteeringWheel(Direction dir);
   void PressBreaker();
   void PrintInfo();

private:
   std::string  m_name;
   std::string  m_brand;
   std::string  m_type;
   int		  m_maxSpeed;
   int		  m_numOfSeats;

   CruiseControl* m_cruiseControl;
   GasPumper*     m_gasPumper;
   EcoBooster*    m_ecoBooster;
};

int Car::PressGasPedal()
{
   //Step 1: kiểm tra và thoát chế độ 
   Cruise Control nếu có
   if (m_cruiseControl->IsEnable())
      m_cruiseControl->Quit();
   //Step 2: tăng điện áp lên bơm xăng
   m_gasPumper->IncreaseVoltage();
   //Step 3: kích hoạt chế độ Eco Booster 
   nếu tốc độ hiện tại đang lớn hơn 40 km/h
   if (GetCurrentSpeed() > 40)
      m_ecoBooster->Enable();
   //Step 4: kết thúc, trả về tín hiệu OK,
   hoặc mã lỗi
   return RESULT_OK;
}
Ví dụ về hàm PressGasPedal():
Mọi chiếc xe đều có hàm này, nhưng impliment như thế nào là tùy từng hãng xe, tùy từng chiếc xe.

Nhận xét tiếp theo, trong các hàm PressGasPedal(), RotateTheSteeringWheel(Direction dir), PressBreaker(), Gần như chúng không sử dụng đến các thuộc tính như m_name, m_type,...
Đôi khi, ban đầu khi xây dựng class, nó mang rất nhiều các thuộc tính mà khi triển khai code, chúng không được dùng tới, 
Hoặc, class có sẵn các hàm mà không có các biện pháp thi hành. Tính trừu tượng này thường được gọi là lớp trừu tượng. Sẽ được giới thiệu ở phần sau

Kết luận về abstraction : 
Là quá trình loại bỏ đi các thông tin thừa, chỉ để lại những thông tin chung, và cần thiết
Tập trung vào các đặc điểm cơ bản của thực thể, để có thể phân biệt nó với các thực thể khác
Phụ thuộc vào góc nhìn: thuộc tính là quan trọng trong ngữ cảnh này, nhưng lại không có ý nghĩa trong ngữ cảnh khác.

int Car::PressGasPedal()
{
   //Step 1: kiểm tra và thoát chế độ 
   Cruise Control nếu có
   if (m_cruiseControl->IsEnable())
      m_cruiseControl->Quit();
   //Step 2: tăng điện áp lên bơm xăng
   m_gasPumper->IncreaseVoltage();
   //Step 3: kích hoạt chế độ Eco Booster 
   nếu tốc độ hiện tại đang lớn hơn 40 km/h
   if (GetCurrentSpeed() > 40)
      m_ecoBooster->Enable();
   //Step 4: kết thúc, trả về tín hiệu OK,
   hoặc mã lỗi
   return RESULT_OK;
}

Quay về ví dụ trước.
Trong hàm không gọi trực tiếp đến các biến, mà đều gọi thông qua các hàm phụ trợ. 
Điều này giúp:
Che giấu, ẩn đi các chi tiết thực hiện bên trong
Cung cấp một giao diện cho các thực thể bên ngoài
Người dùng không được phép trực tiếp sửa đổi các thông tin bên trong đối tượng
Cho phép module hóa, mô tả rõ hơn về hệ thống.


Tính kế thừa (inheritance): Đặc tính này cho phép một đối tượng có thể có sẵn các đặc tính mà đối tượng khác đã có thông qua kế thừa. Điều này cho phép các đối tượng chia sẻ hay mở rộng các đặc tính sẵn có mà không phải tiến hành định nghĩa lại.

Tính đa hình Polymorphism

Xét ví dụ: Ai cũng biết là ô tô thì có còi, nhấn còi thì xe sẽ kêu, và thường là kêu Bíp bíp. Nhưng trong một số trường hợp, một số xe có tiếng kêu rất đặc trưng cho loại xe đó.
Ví dụ còi xe cảnh sát khác với còi xe cứu thương, chưa kể, xe cảnh sát, hay xe cứu thương, khi tham gia giao thông bình thường (không làm nhiệm vụ) thì vẫn kêu bíp bíp.
Bây giờ, chúng ta sẽ dùng C/C++ để mô tả lại ví dụ này, thay tiếng kêu bằng các hàm in ra màn hình các chuỗi ký tự thể hiện âm thanh tương ứng.

Để làm được điều này, trước tiên cùng tìm hiểu các định nghĩa về override, overload, abstract class và interface.

Overriding vs overloading:
Định nghĩa: 
Override (ghi đè) là một tính năng cho phép một lớp con cung cấp một triển khai cụ thể của phương thức đã được cung cấp bởi một trong các lớp cha của nó. 
Overload (nạp chồng) cho phép ta tạo nhiều phiên bản của một phương thức, hoặc toán tử, nhằm tạo ra sự thuận lợi trong việc gọi hàm, hoặc toán tử
Có 2 loại overload: 
function Overloading 
Operator Overloading

Ví dụ Overriding:
class Car
{
public:
  virtual void TurnOnHorn()
  {
    cout << "Beep beep" << endl;
  }
};

class PoliceCar : public Car
{
public:
  virtual void TurnOnHorn()
  {
    cout << " Te tò te tò";
  }
};


vs VD Overloading:
class PoliceCar
{
public:
  void TurnOnHorn(int mode)
  {
    if (mode == 0)
      cout << "Tuuuuu tuuuuu";
    else
      cout << "Te tò te tò" << endl;
  }


  void TurnOnHorn(string voice)
  {
    cout << voice << endl;
  }
};


Operator Overloading:
Ví dụ: Bạn là trưởng phòng IT của một trạm thu phí đường bộ, nằm trên lối vào đường cao tốc Hà Nội- Lào Cai, Trạm có lưu lượng xe qua lại rất lớn, nhưng lại chỉ có 1 cửa vào cao tốc. Các xe phải nằm chờ trong bãi để xe tạm rồi chờ đến lượt mình được gọi. Tình trạng rất hỗn độn, vì thế, sếp của bạn mua một cái cân điện tử đặt ở lối vào, và bắt bạn viết một chương trình để sắp xếp các xe trong bãi theo thứ tự tải trọng giảm dần, làm sao để xe chở nặng nhất được qua trạm trước, xe chở nhẹ hơn sẽ qua trạm sau.
class Car
{
public:
  void SetWeight(int weight) 
  {m_weight = weight;}
  int GetWeight() { return m_weight; }

  bool operator <= (const Car& car) 
  {
     return this->m_weight <= car.m_weight;
  }

private:
  int m_weight;
};
int main() 
{
  list<Car*> carList;
  while (carList.size())
  {
    //Find max:
    Car* car = FindMaxWeight(carList);
    //Push up car to pass by the toll:
    cout << "Mời xe có tải trọng "<< 
	car->GetWeight() <<" qua trạm" << endl;
    carList.remove(car);
    delete car;
  }
  return 0;
}

Please define following function by yourself:
Car* FindMaxWeight(list<Car*> carList)


Abstract class and Interface:
Tiếp tục với khái niệm abstract class và interface.
Định nghĩa:
abstract class là class có chứa một hoặc nhiều phương thức trừu tượng (virtual), 
Interface là class chỉ chứa các phương thức ảo, không có thuộc tính (attributes), các phương thức đều là loại public.
Về mục đích sử dụng:
abstract class: dùng khi mô tả một khuôn mẫu đối tượng với mong muốn có thể tự mở rộng.
Interface: thường được hướng tới việc mô tả một tính năng của module, mà các class base trên nó sẽ follow theo.

Trong C++, abstract và interface không được rõ ràng như các ngôn ngữ thuần OPP khác (như java, thì interface là 1 từ khóa (keyword) luôn), và chúng có tính chất rõ ràng, khác biệt nhau hoàn toàn (Vì thế người ta mới nói C++ là ngôn ngữ lai căng)
class Car
{
public:
  virtual void TurnOnHorn()
  {
    cout << "Beep beep" << endl;
  }
  virtual void PressBreaker()=0;
};
virtual void TurnOnHorn(){}: Function can be overrided or not.
virtual void PressBreaker()=0: Function must be overrided in inheritance class.


Abstract and Interface – apply example on delegate:
Xét một ứng dụng kinh điển của interface trong C++: Delegate (Callback Interface)
Ví dụ: Bạn là một senior developer của một công ty sản xuất xe hơi (Vinfast chẳng hạn), và bạn được giao nhiệm vụ viết code để cho phép người lái khởi động chiếc xe. Khi người dùng nhấn nút Start (hoặc vặn chìa khóa sang ON), Bộ xử lý chính của xe sẽ ra lệnh kiểm tra các điều kiện an toàn trước
Điều kiện an toàn đầu tiên: là dây an toàn ở hàng ghế trước có được thắt đúng hay chưa.
Ở một số xe, bạn phải đạp phanh chân, và hạ phanh tay trước.

Ví dụ này, hãy bỏ qua các điều kiện sau, chỉ xét điều kiện về việc thắt dây an toàn. Nếu  dây an toàn chưa được thắt đúng, hãy làm các việc sau:
Hiển thị thông báo bằng âm thanh, đèn báo
Không cho túi khí bung ra nếu gặp tai nạn (Không có ai đang lái xe, thì bung túi khí làm gì cho tốn kém)
Không cho xe khởi động.

Example on delegate:

class ICallbackDelegate
{
public:
  virtual void OnSeatBeltNotInstalled() {};
};
class SafeCheck
{
public:
  void SetOwnerDelegate(ICallbackDelegate* owner) 
  { m_owner = owner; }
  void Check();
private:
  bool CheckSeatBelt() { return false; }
private:
  ICallbackDelegate* m_owner;
};

class Car : public ICallbackDelegate
{
public:
  Car();
  void Start();
protected:
  virtual void OnSeatBeltNotInstalled()    	{m_isEnableToStart = false;};
private:
  SafeCheck*   	m_safeChecker;
  bool		m_isEnableToStart;
};
Car::Car()
{
  m_safeChecker = new SafeCheck();
  m_safeChecker->SetOwnerDelegate(this);
  m_isEnableToStart = true;
}


void Car::Start()
{
  cout << "Check safe conditional before start the
  car..." << endl;
  if (m_safeChecker != NULL)
    m_safeChecker->Check();
  if (m_isEnableToStart)
    cout << "Realdy to go!" << endl;
  else
    cout << "Please check safe conditional first!" 
    << endl;
}

void SafeCheck::Check()
{
  //Check first seat belt is installed or not?
  //Example case: it's not been wearing.

  if (!CheckSeatBelt())
  {
    //Pushup the callback
    if (m_owner)
      m_owner->OnSeatBeltNotInstalled();
  }
}

4. Assignments: SNAKE GAME ( class diagram, Class relationships, Sequence diagram – example (snake game)
)


DAY 3-4