Trong số nhiều thao tác có sẵn cho “std::map”, chức năng “xóa” nổi bật như một công cụ quan trọng để loại bỏ các phần tử dựa trên khóa của chúng. “std::map” là một vùng chứa kết hợp có tổ chức bao gồm các cặp khóa-giá trị. Việc sắp xếp các phần tử trong một “std::map” được sắp xếp nhất quán theo khóa của chúng, tạo điều kiện thuận lợi cho các hoạt động hiệu quả như tìm kiếm, chèn và xóa dựa trên các giá trị khóa.
Trong lĩnh vực C++, hàm “std::map::erase” đóng vai trò là hàm thành viên của lớp “std::map”, cho phép loại bỏ các phần tử cụ thể khỏi bản đồ. Nó có nhiều dạng khác nhau, mang lại sự linh hoạt trong việc chỉ định thành phần nào cần xóa. Trong bài viết này, chúng ta sẽ đi sâu vào chi tiết về “std::map::erase”, cung cấp nhiều ví dụ để minh họa tính linh hoạt của nó.
Ví dụ 1: Xóa bằng phím
Khả năng xóa các phần tử bằng phím trong “std::map” là một tính năng cơ bản được cung cấp bởi Thư viện mẫu chuẩn C++. Thao tác này thường được sử dụng khi bạn cần quản lý và thao tác các cặp khóa-giá trị trong một chương trình và nó cung cấp một cách thuận tiện để loại bỏ các thành phần cụ thể dựa trên khóa của chúng. Chúng tôi sẽ tạo một ví dụ để minh họa cách sử dụng “std::map” để tạo bản đồ, xóa một phần tử bằng phím và sau đó hiển thị bản đồ đã sửa đổi.
#include
#include
int chính ( ) {
std::bản đồ < int, std::chuỗi > Bản đồ của tôi;
bản đồ của tôi [ 1 ] = 'Màu đỏ' ;
bản đồ của tôi [ 2 ] = 'Màu xanh da trời' ;
bản đồ của tôi [ 3 ] = 'Màu xanh lá' ;
myMap.erase ( 2 ) ;
vì ( const tự động & cặp: myMap ) {
std::cout << cặp.first << ': ' << cặp.giây << std::endl;
}
trở lại 0 ;
}
Trong ví dụ này, chúng tôi bắt đầu bằng cách bao gồm các thư viện chuẩn C++ cần thiết như
Để hiển thị trạng thái kết quả của bản đồ, chúng tôi sử dụng vòng lặp “for” lặp qua từng cặp khóa-giá trị trong “myMap”. Chúng tôi sử dụng đối tượng “std::cout” bên trong vòng lặp để in từng cặp khóa-giá trị ra bảng điều khiển. Cuối cùng, câu lệnh “return 0” kết thúc hàm “main” báo hiệu việc thực hiện thành công chương trình của chúng ta.
Đầu ra hiển thị các cặp khóa-giá trị còn lại trong “std::map” sau khi phần tử có khóa 2 (“Xanh lam”) bị xóa, dẫn đến đầu ra “1: Đỏ” và “3: Xanh lục”.
Ví dụ 2: Xóa bằng Iterator
Trong C++, các trình vòng lặp là các đối tượng tạo điều kiện thuận lợi cho việc điều hướng các phần tử trong vùng chứa, cung cấp phương tiện để truy cập, sửa đổi hoặc xóa các phần tử. Hàm “std::map::erase” cũng có thể được sử dụng với các trình vòng lặp để loại bỏ các phần tử.
Đây là một ví dụ:
#include#include
int chính ( ) {
std::bản đồ < int, std::chuỗi > FruitFolder;
thư mục trái cây [ 1 ] = 'Quả xoài' ;
thư mục trái cây [ 2 ] = 'Quả cam' ;
thư mục trái cây [ 3 ] = 'Quả dứa' ;
thư mục trái cây [ 4 ] = 'Quả nho' ;
tự động nó = FruitMap.find ( 2 ) ;
nếu như ( Nó ! = FruitMap.end ( ) ) {
FruitMap.erase ( Nó ) ;
}
vì ( const tự động & cặp: bản đồ trái cây ) {
std::cout << cặp.first << ': ' << cặp.giây << std::endl;
}
trở lại 0 ;
}
Mã C++ được cung cấp bắt đầu bằng cách khai báo một “std::map” có tên là “fruitMap” để lưu trữ các cặp khóa-giá trị, liên kết các số nguyên với tên trái cây tương ứng. Chúng tôi điền vào bản đồ các mục nhập cho bốn loại trái cây khác nhau: “Xoài”, “Cam”, “Quả thông” và “Nho”. Sau đó, chúng ta sử dụng hàm “find” để lấy một iterator (it) trỏ đến phần tử có giá trị khóa là 2 trong “fruitMap”. Sau đó, chúng tôi kiểm tra xem trình vòng lặp có bằng “end()” hay không để đảm bảo rằng phần tử có khóa được chỉ định tồn tại trong bản đồ.
Trong khối điều kiện, chúng ta xóa phần tử được trỏ đến bởi trình vòng lặp “it” bằng cách sử dụng hàm “xóa”. Cuối cùng, chúng tôi lặp qua các phần tử còn lại trong “fruitMap” đã sửa đổi bằng cách sử dụng vòng lặp “for”.
Đầu ra cuối cùng hiển thị nội dung “fruitMap” đã sửa đổi sau khi xóa.
Ví dụ 3: Xóa một dãy
Vùng chứa “std::map” trong C++ cung cấp một phương thức thuận tiện để xóa các phần tử trong một phạm vi được chỉ định. Chức năng 'xóa' cho phép bạn xóa các phần tử khỏi bản đồ dựa trên các vòng lặp đại diện cho điểm bắt đầu và kết thúc của phạm vi cần xóa.
Bây giờ, hãy khám phá khái niệm xóa một phạm vi bằng cách sử dụng “std::map” với một ví dụ:
#include#include
int chính ( ) {
std::bản đồ < int, std::chuỗi > Bản đồ mới;
Bản đồ mới [ 1 ] = 'Ngựa' ;
Bản đồ mới [ 2 ] = 'Con sư tử' ;
Bản đồ mới [ 3 ] = 'Con hổ' ;
Bản đồ mới [ 4 ] = 'Con mèo' ;
bản đồ mới.erase ( newMap.low_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
vì ( const tự động & cặp: bản đồ mới ) {
std::cout << cặp.first << ': ' << cặp.giây << std::endl;
}
trở lại 0 ;
}
Chương trình bắt đầu bằng cách khai báo một “std::map” có tên “newMap” liên kết các khóa số nguyên với các giá trị chuỗi tương ứng. Sau đó, chúng tôi điền vào bản đồ các cặp khóa-giá trị bằng toán tử dấu ngoặc vuông. Ví dụ: chúng tôi gán các cặp khóa-giá trị (1, “Ngựa”), (2, “Sư tử”), (3, “Hổ”) và (4, “Mèo”) cho “newMap”.
Hoạt động quan trọng tiếp theo liên quan đến việc sử dụng các vòng lặp để xóa các phần tử khỏi bản đồ. Hàm xóa được sử dụng với các đối số “newMap.low_bound(2)” và “newMap.upper_bound(3)”. Thao tác này sẽ xóa các phần tử có phím nằm trong phạm vi (2, 3). Nói cách khác, nó xóa các mục “Sư tử” và “Hổ” khỏi bản đồ. Sau thao tác này, bản đồ chỉ chứa các phần tử có phím 1 và 4, tương ứng với “Ngựa” và “Mèo”.
Cuối cùng, chúng tôi sử dụng vòng lặp “for” dựa trên phạm vi để lặp qua các phần tử còn lại trong bản đồ và in các cặp khóa-giá trị của chúng ra bảng điều khiển.
Kết quả là, đầu ra hiển thị như sau:
Ví dụ 4: Xóa dựa trên vị ngữ
Xóa dựa trên một vị từ đề cập đến việc xóa các phần tử khỏi cấu trúc dữ liệu, chẳng hạn như vùng chứa, dựa trên một điều kiện hoặc tiêu chí đã chỉ định. “std::map::erase” cũng có thể được sử dụng với chức năng vị ngữ để loại bỏ các phần tử có điều kiện. Hãy xem xét ví dụ sau:
#include#include
#include
int chính ( ) {
std::bản đồ < int, std::chuỗi > myMap = {
{ 1 , 'Tháng Giêng' } ,
{ 2 , 'Tháng 2' } ,
{ 3 , 'Bước đều' } ,
{ 4 , 'Tháng tư' } ,
{ 5 , 'Có thể' }
} ;
vị ngữ tự động = [ ] ( const std::pair < int, std::chuỗi >& yếu tố ) {
trở lại phần tử.thứ hai.length ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( myMap.begin ( ) , myMap.end ( ) , Thuộc tính ) , myMap.end ( ) ) ;
std::cout << ' \N Bản đồ sau khi xóa các phần tử dựa trên vị ngữ:' << std::endl;
vì ( const tự động & cặp: myMap ) {
std::cout << cặp.first << ': ' << cặp.giây << std::endl;
}
trở lại 0 ;
}
Chương trình bắt đầu bằng cách bao gồm các tệp tiêu đề cần thiết. Một “std::map” có tên là “myMap” được khai báo và khởi tạo trong hàm “main”. Nó chứa các cặp khóa-giá trị đại diện cho tên của tháng và các giá trị số tương ứng của chúng. Sau đó, hàm (vị ngữ) “lambda” được xác định. Hàm “lambda” này đóng vai trò là vị ngữ cho thuật toán “std::remove_if”. Nó xác minh xem độ dài của giá trị chuỗi được liên kết với phần tử bản đồ có nhỏ hơn năm ký tự hay không.
Sau đó, thuật toán “std::remove_if’ được sử dụng cùng với chức năng “xóa” của “std::map”. Sự kết hợp này loại bỏ các phần tử khỏi bản đồ dựa trên tính hợp lệ của vị từ.
Sau khi chạy chương trình, các phần tử có khóa nhỏ hơn năm sẽ bị xóa khỏi bản đồ gốc, thể hiện việc xóa dựa trên một vị từ bằng cách sử dụng “std::map”.
Phần kết luận
Tóm lại, hàm “std::map::erase” là một công cụ linh hoạt trong C++ để loại bỏ các phần tử khỏi “std::map”. Cho dù xóa theo khóa, trình vòng lặp, phạm vi hay dựa trên một vị từ, chức năng “std::map::erase” mang lại sự linh hoạt và dễ sử dụng. Bằng cách nắm vững chức năng này, các nhà phát triển C++ có thể quản lý và thao tác dữ liệu một cách hiệu quả trong vùng chứa “std::map”, giúp mã của họ mạnh hơn và dễ bảo trì hơn.