Kiến Thức Cơ Bản về C++

C++ là một ngôn ngữ lập trình mạnh mẽ, đa năng và hướng đối tượng, được phát triển dựa trên ngôn ngữ C. Nó được sử dụng rộng rãi trong phát triển phần mềm hệ thống, trò chơi, ứng dụng desktop, và nhiều lĩnh vực khác.

Cấu Trúc Cơ Bản của một Chương Trình C++

Mỗi chương trình C++ cơ bản đều có một hàm main() là điểm khởi đầu cho việc thực thi.

#include <bits/stdc++.h> // Bao gồm hầu hết các thư viện chuẩn C++

int main() {
    // Đây là nơi code của bạn sẽ được viết
    std::cout << "Xin chào thế giới!" << std::endl; // In ra màn hình
    return 0; // Trả về 0 báo hiệu chương trình kết thúc thành công
}

Các Khái Niệm Chính

Biến (~variable~)

Biến là một vùng nhớ được đặt tên dùng để lưu trữ dữ liệu. Bạn phải khai báo kiểu dữ liệu cho ~variable~ trước khi sử dụng.

Ví dụ:

• int ~age~ = 30; // Khai báo một biến số nguyên có tên ~age~ và gán giá trị 30.
• double ~price~ = 19.99; // Khai báo một biến số thực có tên ~price~.
• char ~grade~ = 'A'; // Khai báo một biến ký tự có tên ~grade~.
• std::string ~name~ = "Alice"; // Khai báo một biến chuỗi có tên ~name~.

Kiểu Dữ Liệu (Data Types)

C++ có nhiều kiểu dữ liệu cơ bản:

• Số nguyên: int, short, long, long long (dùng cho các số nguyên không có phần thập phân).
• Số thực: float, double, long double (dùng cho các số có phần thập phân).
• Ký tự: char (dùng cho một ký tự đơn).
• Boolean: bool (chỉ có hai giá trị: true hoặc false).
• Chuỗi: std::string (là một lớp trong thư viện chuẩn, không phải kiểu dữ liệu nguyên thủy).

Toán Tử (Operators)

Toán tử là các ký hiệu dùng để thực hiện các phép toán trên các ~variable~ và giá trị.

• Toán tử số học: + (cộng), - (trừ), * (nhân), / (chia), % (chia lấy dư).
  • Ví dụ: x + y, a / b
• Toán tử so sánh: == (bằng), != (khác), > (lớn hơn), < (nhỏ hơn), >= (lớn hơn hoặc bằng), <= (nhỏ hơn hoặc bằng).
  • Ví dụ: age > 18, name == "Bob"
• Toán tử logic: && (AND), || (OR), ! (NOT).
  • Ví dụ: isAdult && hasLicense, !isValid
• Toán tử gán: = (gán giá trị), +=, -=, *=...
  • Ví dụ: total += amount

Câu Lệnh Điều Khiển (Control Flow Statements)

Cho phép chương trình đưa ra quyết định hoặc lặp lại các tác vụ.

• if, else if, else: Thực thi code dựa trên một điều kiện.

  if (score >= 90) {
      std::cout << "Xuất sắc!" << std::endl;
  } else if (score >= 70) {
      std::cout << "Khá!" << std::endl;
  } else {
      std::cout << "Cần cố gắng thêm." << std::endl;
  }
  

• switch: Một cách khác để xử lý nhiều điều kiện.

  switch (dayOfWeek) {
      case 1:
          std::cout << "Chủ Nhật" << std::endl;
          break;
      case 2:
          std::cout << "Thứ Hai" << std::endl;
          break;
      default:
          std::cout << "Ngày không hợp lệ" << std::endl;
          break;
  }
  

• Vòng lặp for: Lặp lại một khối code một số lần nhất định.

  for (int i = 0; i < 5; ++i) {
      std::cout << "Lần lặp thứ: " << i << std::endl;
  }
  

• Vòng lặp while: Lặp lại một khối code cho đến khi một điều kiện trở thành false.

  int count = 0;
  while (count < 3) {
      std::cout << "Count: " << count << std::endl;
      count++;
  }
  

• Vòng lặp do-while: Tương tự while, nhưng đảm bảo khối code được thực thi ít nhất một lần.

  int num;
  do {
      std::cout << "Nhập một số dương: ";
      std::cin >> num;
  } while (num <= 0);
  

Hàm (Functions)

Hàm là một khối code được đặt tên, thực hiện một nhiệm vụ cụ thể. Hàm giúp tái sử dụng code và tổ chức chương trình tốt hơn.

// Khai báo hàm
void greet(std::string name) {
    std::cout << "Xin chào, " << name << "!" << std::endl;
}

// Hàm có giá trị trả về
int add(int a, int b) {
    return a + b;
}

int main() {
    greet("World"); // Gọi hàm greet
    int sum = add(5, 3); // Gọi hàm add và lưu kết quả
    std::cout << "Tổng là: " << sum << std::endl;
    return 0;
}

Mảng (Arrays)

Mảng là một tập hợp các phần tử cùng kiểu dữ liệu, được lưu trữ liên tiếp trong bộ nhớ.

int numbers[5] = {10, 20, 30, 40, 50}; // Khai báo và khởi tạo mảng 5 phần tử
std::cout << "Phần tử thứ ba: " << numbers[2] << std::endl; // Truy cập phần tử (chỉ số bắt đầu từ 0)

Con Trỏ (Pointers)

Con trỏ là một \~variable\~ lưu trữ địa chỉ bộ nhớ của \~variable\~ khác.

• int* \~ptr\~; // Khai báo một con trỏ kiểu int.
• ptr = &value; // Gán địa chỉ của \~value\~ cho \~ptr\~ (toán tử & lấy địa chỉ).
• *ptr // Truy cập giá trị tại địa chỉ mà con trỏ \~ptr\~ đang trỏ tới (toán tử * dereference).

Ví dụ:

int x = 10;
int* p = &x; // p chứa địa chỉ của x

std::cout << "Giá trị của x: " << x << std::endl; // 10
std::cout << "Địa chỉ của x: " << &x << std::endl; // Một địa chỉ bộ nhớ
std::cout << "Giá trị mà p trỏ tới: " << *p << std::endl; // 10 (truy cập giá trị qua con trỏ)
std::cout << "Địa chỉ mà p đang giữ: " << p << std::endl; // Giống địa chỉ của x

Lập Trình Hướng Đối Tượng (OOP)

C++ là một ngôn ngữ hướng đối tượng, với các khái niệm chính:

• Lớp (Classes): Là một bản thiết kế (blueprint) để tạo ra các đối tượng. Nó định nghĩa các thuộc tính (attributes) và hành vi (behaviors) mà các đối tượng thuộc lớp đó sẽ có.

  class Car {
  public: // Các thành viên có thể truy cập từ bên ngoài
      std::string brand;
      std::string model;
      int year;
  
      // Phương thức (hành vi)
      void displayInfo() {
          std::cout << "Brand: " << brand << ", Model: " << model << ", Year: " << year << std::endl;
      }
  
      // Constructor (hàm khởi tạo)
      Car(std::string b, std::string m, int y) {
          brand = b;
          model = m;
          year = y;
      }
  };
  

• Đối tượng (Objects): Là một thể hiện (instance) của một lớp. Bạn tạo đối tượng từ một lớp.

  int main() {
      Car myCar("Toyota", "Camry", 2020); // Tạo đối tượng myCar từ lớp Car
      myCar.displayInfo(); // Gọi phương thức của đối tượng
      return 0;
  }
  

• Tính đóng gói (Encapsulation): Gói gọn dữ liệu (thuộc tính) và các phương thức hoạt động trên dữ liệu đó vào một đơn vị duy nhất (lớp), và kiểm soát quyền truy cập vào chúng.

• Tính kế thừa (Inheritance): Cho phép một lớp (lớp con) kế thừa các thuộc tính và phương thức từ một lớp khác (lớp cha), giúp tái sử dụng code.

• Tính đa hình (Polymorphism): Cho phép các đối tượng thuộc các lớp khác nhau được xử lý thông qua một giao diện chung, thường thông qua các hàm ảo (virtual functions).

• Tính trừu tượng (Abstraction): Ẩn đi các chi tiết triển khai phức tạp và chỉ hiển thị những thông tin cần thiết cho người dùng.

Hy vọng phiên bản này phù hợp với yêu cầu của bạn! Bạn có muốn tìm hiểu thêm về bất kỳ khái niệm cụ thể nào không?