Vector trong C++: Định nghĩa, cách sử dụng và các hàm phổ biến

Trong lập trình C++, vector là công cụ giúp bạn dễ dàng thêm, xóa và truy cập các phần tử mà không cần lo lắng về việc quản lý bộ nhớ thủ công. Trong bài viết này, mình sẽ chia sẻ tới bạn những thông tin tổng quan về vector trong C++, từ định nghĩa, cách khai báo, khởi tạo vector, các hàm thông dụng và ứng dụng thực tế trong lập trình.

Những điểm chính

• Khái niệm: Vector trong C++ là một mảng động, có khả năng tự thay đổi kích thước để lưu trữ các phần tử cùng kiểu dữ liệu.
• Ưu điểm: So với mảng truyền thống, vector không cần khai báo kích thước trước, tự động điều chỉnh kích thước, cho biết số lượng phần tử và có thể sử dụng chỉ số âm.
• Cách khai báo và khởi tạo: Bạn sẽ biết cách khai báo, khởi tạo vector, thêm phần tử, truy cập phần tử, xóa phần tử và duyệt qua các phần tử.
• Standard Template Library (STL): Biết về STL, một thư viện cung cấp các cấu trúc dữ liệu và thuật toán tổng quát với 4 thành phần container, thuật toán, hàm và iterator.
• Cách vector hoạt động: Biết được cách vector ngăn ngừa rò rỉ bộ nhớ và theo dõi kích thước của nó.
• Nén giá trị boolean: Biết cách tối ưu nhất để lưu trữ các giá trị boolean là sử dụng std::vector<bool>.
• Các hàm thông dụng của vector: Mình sẽ liệt kê và giải thích các hàm thuộc các nhóm: Modifier, Iterator, Capacity, Element access.
• Ứng dụng thực tế: Vector có thể được sử dụng thay thế cho mảng một chiều và mảng hai chiều trong lập trình C++, với các ví dụ minh họa cách nhập dữ liệu cho cả hai trường hợp.
• Biết đến Vietnix là nhà cung cấp VPS tốc độ cao giúp tối ưu hiệu suất website.

Vector trong C++ là gì?

Vector trong C++ là một container kiểu mảng động (dynamic array) dùng để lưu trữ các phần tử có cùng kiểu dữ liệu và có thể thay đổi kích thước khi có phần tử được chèn vào hoặc bị xóa đi. Sự khác biệt giữa mảng và vector là kích thước của mảng không thể thay đổi (bạn không thể thêm hoặc xóa phần tử khỏi mảng) còn vector có thể tăng hoặc giảm kích thước tùy theo nhu cầu. Các phần tử vector C++ được đặt trong một bộ nhớ liền kề (contiguous storage), cho phép truy cập và duyệt thông qua một trình vòng lặp (iterator).

Vì sao nên sử dụng Vector C++?

Với vector C++, các developer không còn phải thực hiện nhiều thao tác thừa thãi, lặp đi lặp lại khi phải làm việc với mảng ở trong C++. Dưới đây là một số ưu điểm của kiểu vector trong C++ so với mảng truyền thống:

• Không cần phải khai báo kích thước của mảng vì vector có khả năng tự resize.
• Tự động điều chỉnh kích thước để chèn phần tử nếu vector đã đầy.
• Cho biết số lượng các phần tử đang được lưu trữ.
• Cho phép sử dụng chỉ số âm (chẳng hạn như A[-6], A[-5],…).

Cách khai báo và khởi tạo vector trong C++

Để có thể sử dụng được vector trong C++ bạn cần khai báo header vector và thư viện std. Dưới đây là cách sử dụng vector trong C++, bắt đầu từ khai báo thư viện vector và khởi tạo vector:

1. Khai báo vector trong C++

#include<vector>
    using namespace std;

2. Khởi tạo vector

std::vector<int> vec; // khởi tạo một vector không có phần tử nào

3. Thêm phần tử vào cuối vector

vec.push_back(10); // Thêm phần tử 10 vào cuối vector
vec.push_back(20); // Thêm phần tử 20 vào cuối vector

4. Truy cập phần tử của vector

int firstElement = vec[0]; // Truy cập phần tử đầu tiên (index bắt đầu từ 0)
int secondElement = vec.at(1); // Truy cập phần tử thứ hai, sử dụng at() để có kiểm tra chỉ số an toàn

5. Loại bỏ phần tử khỏi vector

vec.pop_back(); // Loại bỏ phần tử cuối cùng của vector

6. Duyệt qua các phần tử của vector

for (int i = 0; i < vec.size(); i++) {
    std::cout << vec[i] << std::endl; // In ra từng phần tử của vector
}

// Hoặc sử dụng iterator
for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << std::endl; // In ra từng phần tử của vector
}

// Hoặc sử dụng range-based for loop (C++11 trở lên)
for (int val : vec) {
    std::cout << val << std::endl; // In ra từng phần tử của vector
}

7. Lấy kích thước của vector

size_t numElements = vec.size(); // Lấy số lượng phần tử hiện tại trong vector

Trên đây là những hàm để sử dụng cho vector trong C++ bạn có thể theo dõi tiếp phần tiếp theo để biết thêm chi tiết.

Standard Template Library (STL) là một tập hợp các lớp mẫu (template class), cung cấp các cấu trúc dữ liệu và hàm phổ biến như list, stack, array,… Đây là một thư viện bao gồm các lớp container, thuật toán và iterator. Vì là một thư viện có tính tổng quát nên mọi phần tử của thư viện đều được tham số hoá. Để làm việc được với STL, các developer cần có kiến thức cơ bản về việc xử lý các template class.

Thuật toán

Thuật toán header xác định một tập hợp các hàm được thiết kế đặc biệt để sử dụng trên các phạm vi phần tử. Thành phần này hoạt động trên các container và cung cấp phương thức cho nhiều thao tác của container.

Container

Container lưu trữ các đối tương và dữ liệu, với tổng cộng bảy lớp theo tiêu chuẩn “first-class“, ba lớp adaptor và 7 file header cung cấp quyền truy cập vào những container/container adaptor này.

• Sequence container: Triển khai các cấu trúc dữ liệu có thể được truy cập theo cách tuần tự.
  • vector
  • list
  • deque
  • array
  • forward_list

• Container adaptor: Cung cấp nhiều giao diện khác cho các container tuần tự.
  • queue
  • priority_queue
  • stack
• Associative container: Triển khai cấu trúc dữ liệu được sắp xếp, có thể tìm kiếm với độ phức tạp O(logn)
• Unordered Associative Container: Triển khai cấu trúc dữ liệu không có thứ tự.
  • unordered_set
  • unordered_multiset
  • unordered_map
  • unordered_multimap

Bạn có thể tìm hiểu thêm cách sắp xếp bằng các thuật toán sắp xếp như QuickSort.

Hàm

STL bao gồm nhiều class có thể overload toán tử gọi hàm. Các instance của những class này được gọi là đối tượng hàm (functor). Các functor cho phép tuỳ chỉnh hoạt động của hàm thông qua các tham số được truyền.

Iterator

Đúng như tên gọi, iterator được sử dụng để làm việc với các chuỗi giá trị. Đây cũng là tính năng chính để đảm bảo tính khái quát hoá của STL.

Trong những phần còn lại của bài viết, ta sẽ tìm hiểu cách sử dụng thư viện vector trong C++. Trước hết, để tạo một vector, ta cần sử dụng cú pháp như dưới đây:

vector <object_type> variable_name;

Ví dụ:

#include <iostream>
#include <vector>
#include <string>

class Car {
public:
    std::string make;
    std::string model;
    int year;

    Car(std::string m, std::string mod, int y) : make(m), model(mod), year(y) {}

    void display() const {
        std::cout << "Brand: " << make << " " << model << ", Year: " << year << std::endl;
    }
};

int main() {
    // Tạo một vector chứa các đối tượng Car.
    std::vector<Car> garage;

    // Thêm các đối tượng Car vào trong vector.
    garage.emplace_back("Vietnix.vn", "VPS,Hosting", 2023);
    garage.emplace_back("Honda", "Accord", 2019);
    garage.emplace_back("Tesla", "Model S", 2021);

    // Hiển thị thông tin của từng chiếc xe trong garage.
    for (const Car& car : garage) {
        car.display();
    }

    return 0;
}

Output:

Ví dụ trên minh họa việc sử dụng vector để lưu trữ các đối tượng trong ngôn ngữ lập trình C++.

Cách Vector ngăn chặn rò rỉ bộ nhớ

Khi một đối tượng Vector vượt ra khỏi ranh giới phạm vi trong code, sẽ tự động thực hiện việc giải phóng các khu vực bộ nhớ dưới quyền kiểm soát của mình. Sự tự quản này không những giảm bớt gánh nặng quản lý bộ nhớ từ phía lập trình viên, mà còn là hệ thống phòng vệ hiệu quả chống lại các lỗi rò rỉ bộ nhớ.

#include <iostream>
#include <vector>

class Widget {
public:
    Widget() { std::cout << "Widget constructed\n"; }
    ~Widget() { std::cout << "Widget destroyed\n"; }
};

int main() {
    {
        std::vector<Widget> widgetList;
        widgetList.push_back(Widget());
        widgetList.push_back(Widget());
        std::cout << "Inside the block\n";
        // Khi ra khỏi block này, widgetList sẽ bị phá hủy
    } // widgetList destructor is called here automatically

    std::cout << "Outside the block\n";

    return 0;
}

Output:

Như bạn thấy trong ví dụ, ngay khi block code chứa vector widgetList kết thúc, destructor của std::vector được gọi, tự động giải phóng bộ nhớ và gọi destructor của mỗi đối tượng Widget bên trong. Điều này minh họa rằng không cần thực hiện bất kỳ bước giải phóng bộ nhớ nào một cách thủ công std::vector làm tất cả mọi thứ liên quan đến quản lý bộ nhớ.

Tự động ghi nhớ độ dài của Vector

Khác với mảng động được tích hợp sẵn của C++, vốn không biết được độ dài của mảng, std::vectors tự động theo dõi độ dài của chúng. Để lấy được độ dài của vector, bạn có thể sử dụng hàm size().

#include <iostream>
#include <vector>

int main() {
    // Khởi tạo một vector
    std::vector<int> vec;

    // Thêm giá trị vào vector
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);

    // In độ dài của vector sử dụng hàm size()
    std::cout << "The size of the vector is: " << vec.size() << std::endl;

    // Duyệt qua vector và in các giá trị
    std::cout << "The elements in the vector are: ";
    for (int i = 0; i < vec.size(); i++) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;

    // Hoặc sử dụng iterator
    std::cout << "The elements in the vector using iterator are: ";
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

Output:

Đoạn code trên, bạn sẽ thấy rằng std::vector tự động cập nhật kích thước của mình khi bạn thêm hoặc xóa phần tử. Hàm size() sẽ luôn cung cấp số lượng phần tử hiện tại trong vector.

Nén nhiều giá trị bools trong C++

Trong C++, bạn có thể nén nhiều giá trị boolean sử dụng một số cách khác nhau. Một trong những cách hiệu quả nhất là sử dụng std::vector<bool>, đây là một template đặc biệt của std::vector đã được tối ưu hóa để lưu trữ boolean mà chỉ sử dụng một bit cho mỗi giá trị, thay vì sử dụng ít nhất một byte mà thông thường một biến bool sẽ chiếm dụng.

#include <iostream>
#include <vector>

int main() {
    // Khởi tạo một vector của boolean với 10 giá trị false
    std::vector<bool> bools(10, false);

    // Thiết lập một số giá trị là true
    bools[1] = true;
    bools[5] = true;
    bools[7] = true;

    // In ra các giá trị trong vector
    for (bool value : bools) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    return 0;
}

Output:

Modifier

1. push_back(): Đẩy phần tử vào vị trí cuối của vector. Nếu kiểu đối tượng được truyền dưới dạng tham số trong push_back() không giống với kiểu vector thì sẽ trả về Exception.
2. assign(): Gán giá trị mới vào các phần tử.
3. pop_back(): Dùng để pop hoặc xoá phần tử ở cuối vector, đồng thời giảm kích thước của vector đi 1 đơn vị.
4. insert(): Chèn phần tử mới vào phía trước phần tử trước vị trí trỏ của iterator. Ngoài ra ta cũng có thể thêm đối số count để đếm số lần chèn phần tử.
5. erase(): Xoá phần tử khỏi container dựa trên vị trí hoặc phạm vi nhất định. Người dùng có thể truyền vị trí của phần tử cần xoá hoặc truyền phạm vi của phần tử.
6. swap(): Dùng để hoán đổi nội dung của một vetor với vector khác có cùng kiểu (kích thước có thể khác nhau).
7. clear(): Xoá mọi phần tử của vector container.

Ví dụ:

#include <iostream>
#include <vector>
void print_vector(const std::vector<int>& vec) {
    for (int num : vec) {
        std::cout << num << " ";
    }
    std::cout << "\n";
}
int main() {
    std::vector<int> ten_vector;
    // push_back()
    ten_vector.push_back(10);
    ten_vector.push_back(20);
    std::cout << "Vector sau khi push_back: ";
    print_vector(ten_vector);
    // assign()
    ten_vector.assign(5, 100);
    std::cout << "Vector sau khi assign: ";
    print_vector(ten_vector);
    // pop_back()
    ten_vector.pop_back();
    std::cout << "Vector sau khi pop_back: ";
    print_vector(ten_vector);
    // insert()
    auto it = ten_vector.begin();
    ten_vector.insert(it + 2, 500);
    std::cout << "Vector sau khi insert: ";
    print_vector(ten_vector);
    // erase()
    ten_vector.erase(ten_vector.begin() + 1);
    std::cout << "Vector sau khi erase: ";
    print_vector(ten_vector);
    // swap()
    std::vector<int> another_vector = {1, 2, 3};
    ten_vector.swap(another_vector);
    std::cout << "Vector sau khi swap (ten_vector): ";
    print_vector(ten_vector);
    std::cout << "another_vector sau khi swap: ";
    print_vector(another_vector);
    // clear()
    ten_vector.clear();
    std::cout << "Vector sau khi clear: ";
    print_vector(ten_vector);
    std::cout << "ten_vector rỗng sau khi clear: " << std::boolalpha << ten_vector.empty() << "\n";
    return 0;
}

Output:

Iterator

1. begin(): Trả về iterator đang trỏ đến phần tử đầu tiên của vector.
2. end(): Trả về iterator đang trỏ đến phần tử cuối cùng của vector.

Ví dụ:

#include <iostream>
#include <vector>
int main() {
    std::vector<int> ten_vector = {10, 20, 30, 40, 50};
    // begin(): Lấy iterator đến phần tử đầu tiên của vector.
    auto it_begin = ten_vector.begin();
    std::cout << "Giá trị tại iterator đầu tiên: " << *it_begin << std::endl;
    // end(): Lấy iterator đến "sau" phần tử cuối cùng của vector (không phải là phần tử cuối cùng).
    auto it_end = ten_vector.end();
    // Dùng iterator để duyệt vector.
    std::cout << "Vector: ";
    for (auto it = it_begin; it != it_end; ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    return 0;
}

Output:

Trong ví dụ trên, ta đã định nghĩa một vector có tên vec1, sau đó đẩy các giá trị từ 1 đến 10 vào vector bằng một vòng lặp và hàm push_back trong C++. Câu lệnh tiếp theo dùng để in giá trị của vector bằng vòng lặp for, sử dụng begin() và end() để chỉ định điểm đầu và cuối của vòng lặp.

Capacity

1. size(): Trả về số lượng phần tử có trong vector.
2. max_size(): Trả về số lượng phần tử lớn nhất vector có thể chứa.
3. capacity(): Trả về kích thước không gian lưu trữ hiện được cấp cho vector, biểu thị bằng số phần tử dựa trên bộ nhớ được cấp cho vector.
4. resize(): Đổi kích thước container để chứa được n phần tử. Nếu kích thước hiện tại của vector lớn hơn n thì các phần tử ở sau sẽ bị xoá bị vector. Ngược lại, nếu kích thước hiện tại nhỏ hơn n thì các phần tử sẽ được chèn bổ sung vào cuối vector.
5. empty(): Trả về True nếu vector đang trống, nếu không thì False.

#include <iostream>
#include <vector>
int main() {
    // Khởi tạo vector với 5 phần tử.
    std::vector<int> ten_vector = {10, 20, 30, 40, 50};
    // size(): Lấy số lượng phần tử trong vector.
    std::cout << "Kích thước của vector: " << ten_vector.size() << std::endl;
    // max_size(): Lấy số lượng phần tử lớn nhất mà vector có thể chứa.
    std::cout << "Số lượng phần tử lớn nhất mà vector có thể chứa: " << ten_vector.max_size() << std::endl;
    // capacity(): Lấy kích thước không gian lưu trữ hiện tại của vector.
    std::cout << "Kích thước không gian lưu trữ được cấp phát cho vector: " << ten_vector.capacity() << std::endl;
    // resize(): Thay đổi kích thước của vector.
    ten_vector.resize(3); // Đổi kích thước của vector xuống còn 3 phần tử.
    std::cout << "Kích thước mới của vector sau khi resize: " << ten_vector.size() << std::endl;
    // Hiển thị vector sau khi resize.
    for (int i : ten_vector) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    ten_vector.resize(5, 100); // Tăng kích thước lên 5 và thêm giá trị 100 vào các phần tử mới.
    // Hiển thị vector sau khi resize một lần nữa.
    for (int i : ten_vector) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    // empty(): Kiểm tra xem vector có trống không.
    std::cout << "Vector có trống không? " << (ten_vector.empty() ? "Có" : "Không") << std::endl;
    // Làm rỗng vector và kiểm tra lại.
    ten_vector.clear();
    std::cout << "Vector có trống không sau khi clear? " << (ten_vector.empty() ? "Có" : "Không") << std::endl;
    return 0;
}

Output:

Element access

1. at(g): Phương thức này cung cấp một tham chiếu đến phần tử nằm tại vị trí ‘g’ của vector, ví dụ sử dụng: ten_vector.at(position).
2. data(): Phương thức này trả về một con trỏ chỉ đến mảng bộ nhớ mà vector sử dụng để chứa các phần tử của mình, có thể được gọi thông qua: ten_vector.data().
3. front(): Sử dụng phương thức này để truy xuất phần tử đầu tiên trong vector, có thể gọi bằng: ten_vector.front().
4. back(): Phương thức này cho phép lấy phần tử cuối cùng trong vector, ví dụ: ten_vector.back().

#include <iostream>
#include <vector>
int main() {
    // Khởi tạo vector với 5 phần tử.
    std::vector<int> ten_vector = {10, 20, 30, 40, 50};
    // at(g): Truy cập phần tử tại vị trí g, ví dụ tại vị trí 1.
    int position = 1;
    std::cout << "Phần tử tại vị trí " << position << ": " << ten_vector.at(position) << std::endl;
    // data(): Lấy con trỏ đến mảng bộ nhớ của vector.
    int* ptr = ten_vector.data();
    std::cout << "Giá trị của phần tử đầu tiên thông qua con trỏ: " << *ptr << std::endl;
    // front(): Lấy phần tử đầu tiên của vector.
    int front_element = ten_vector.front();
    std::cout << "Phần tử đầu tiên của vector: " << front_element << std::endl;
    // back(): Lấy phần tử cuối cùng của vector.
    int back_element = ten_vector.back();
    std::cout << "Phần tử cuối cùng của vector: " << back_element << std::endl;
    return 0;
}

Output:

Sử dụng Vector thay cho mảng 1 chiều

Bạn có thể sử dụng vector thay thế cho mảng 1 chiều trong mọi bài toán. Dưới đây là 2 cách nhập dữ liệu bằng vector:

Cách 1: Khởi tạo vector rỗng và thêm phần tử dần dần

Đầu tiên, bạn khai báo một vector rỗng và nhập số lượng phần tử mong muốn. Vòng lặp for được sử dụng để nhập từng phần tử và thêm vào cuối vector bằng phương thức push_back().

#include <iostream>
#include <vector>
using namespace std;
int main(){
    vector<int> v;
    int n, tmp; cout << "Nhap so luong phan tu : ";
    cin >> n;
    for(int i = 0; i < n; i++){
        cout << "Nhap phan tu thu " << i + 1 << " : ";
        cin >> tmp;
        v.push_back(tmp);
    }
    cout << "Day so vua nhap : \n";
    for(int i = 0; i < v.size(); i++){
        cout << v[i] << " ";
    }
    return 0;
}

Cách 2: Khởi tạo vector với kích thước cố định

Cách thứ hai là bạn sẽ nhập số lượng phần tử và khởi tạo vector với kích thước tương ứng ngay từ đầu. Sau đó sử dụng vòng lặp for để nhập giá trị cho từng phần tử trong vector.

#include <iostream>
#include <vector>
using namespace std;
int main(){
    int n, tmp; cout << "Nhap so luong phan tu : ";
    cin >> n;
    vector<int> v(n);
    for(int i = 0; i < n; i++){
        cout << "Nhap phan tu thu " << i + 1 << " : ";
        cin >> v[i];
    }
    cout << "Day so vua nhap : \n";
    for(int i = 0; i < v.size(); i++){
        cout << v[i] << " ";
    }
    return 0;
}

Sử dụng Vector thay cho mảng 2 chiều

Để sử dụng Vector thay cho mảng 2 chiều thì bạn cần dùng vector chứa các vector con theo một trong 2 cách sau.

Cách 1: Nhập từng dòng

Với cách này, mỗi dòng của mảng 2 chiều được nhập như một vector riêng biệt, sau đó được thêm vào vector chính.

#include <iostream>
#include <vector>
using namespace std;
int main(){
    int n, m;
    cout << "Nhap hang, cot : ";
    cin >> n >> m;
    vector<vector<int>> v;
    for(int i = 0; i < n; i++){
        vector<int> row;
        for(int j = 0; j < m; j++){
            cout << "Nhap phan tu hang " << i + 1 << ", cot " << j + 1 << " : ";
            int tmp; cin >> tmp;
            row.push_back(tmp);
        }   
        v.push_back(row);
    }
    cout << "\nMang 2 chieu vua nhap : \n";
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cout << v[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

Cách 2: Khởi tạo vector với kích thước cố định

Cách này khởi tạo vector với số dòng và số cột xác định trước.

#include <iostream>
#include <vector>
using namespace std;
int main(){
    int n, m;
    cout << "Nhap hang, cot : ";
    cin >> n >> m;
    vector<vector<int>> v(n, vector<int>(m));
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cout << "Nhap phan tu hang " << i + 1 << ", cot " << j + 1 << " : ";
            cin >> v[i][j];
        }   
    }
    cout << "\nMang 2 chieu vua nhap : \n";
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++){
            cout << v[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

Tối ưu hiệu suất website với VPS tốc độ cao từ Vietnix

Với kinh nghiệm hơn 13 năm phục vụ hơn 100.000 khách hàng cá nhân và doanh nghiệp, Vietnix cung cấp nền tảng vững chắc, đáng tin cậy cho sự phát triển của bạn. Được trang bị ổ cứng NVMe và hạ tầng mạng 10Gbps, VPS Vietnix mang đến hiệu suất xử lý vượt trội và tăng tốc độ tải trang. Với uptime lên đến 99.9%, bạn hoàn toàn yên tâm về sự ổn định của dịch vụ. Đội ngũ hỗ trợ kỹ thuật 24/7 sẵn sàng giải đáp mọi thắc mắc và xử lý sự cố nhanh chóng.

Thông tin liên hệ:

• Hotline: 18001093.
• Email: sales@vietnix.com.vn.
• Địa chỉ: 265 Hồng Lạc, Phường 10, Quận Tân Bình, Thành Phố Hồ Chí Minh.
• Website: https://vietnix.vn/.

Trong bài viết này, mình đã các kiến thức cơ bản nhất về cách sử dụng vector trong C++ cũng như những hàm phổ biến. Hy vọng qua đó bạn đã có thể hình dung ra những cách khác nhau để sử dụng và định nghĩa vector ở trong C++. Để tìm hiểu thêm các kiến thức chuyên sâu khác về lập trình, bạn có thể xem qua những bài viết dưới đây của mình: