Trong lĩnh vực lập trình C++, việc ưu tiên hiệu quả và hiệu suất là rất quan trọng. Lớp “std::string_view”, được giới thiệu trong C++17, trình bày một giải pháp thay thế linh hoạt và tiết kiệm bộ nhớ cho thao tác chuỗi truyền thống. Về cốt lõi, “std::string_view” là một tham chiếu không sở hữu một chuỗi ký tự, thường đại diện cho một chuỗi con của một chuỗi lớn hơn. Không giống như “std::string” sở hữu dữ liệu và quản lý bộ nhớ nội bộ, “std::string_view” hoạt động mà không sở hữu dữ liệu cơ bản. Đặc điểm này làm cho nó đặc biệt có giá trị trong các tình huống không mong muốn việc sao chép hoặc quản lý bộ nhớ. Trong bài viết này, chúng ta sẽ khám phá các ví dụ khác nhau để hiểu cách sử dụng “std::string_view” trong C++.
Ví dụ 1: Xử lý chuỗi hiệu quả
Trong quá trình phát triển C++ hiện đại, việc xử lý chuỗi hiệu quả là rất quan trọng để tối ưu hóa hiệu suất và việc sử dụng tài nguyên. Nó cho phép truy cập và thao tác chuỗi một cách hiệu quả mà không cần phân bổ lại hoặc sao chép bộ nhớ. Để minh họa khái niệm này, chúng ta hãy đi sâu vào một ví dụ thực tế.
Hãy xem xét đoạn mã sau:
#include
#include
quá trình trốngStringView ( std::string_view strView ) {
std::cout << 'Chiều dài: ' << strView.length ( ) << std::endl;
std::cout << 'Nội dung: ' << strView << std::endl;
}
int chính ( ) {
std::string gốcString = 'Xử lý chuỗi hiệu quả' ;
std::string_view viewOfString ( chuỗi gốc ) ;
quá trìnhStringView ( lượt xemOfString ) ;
trở lại 0 ;
}
Trong ví dụ này, chúng ta có hàm “processStringView” lấy “std::string_view” làm tham số. Sau đó, hàm này in độ dài và nội dung của chế độ xem chuỗi bằng đầu ra tiêu chuẩn. Hàm chính khởi tạo “std::string” có tên “originString” với giá trị “Xử lý chuỗi hiệu quả”. Sau đó, “std::string_view” có tên ‘viewOfString” được tạo, đề cập đến nội dung của “originString”.
Bằng cách chuyển “viewOfString” sang hàm “processStringView”, chúng ta có thể thực hiện các thao tác trên chuỗi một cách hiệu quả, loại bỏ nhu cầu phân bổ thêm bộ nhớ. “std::string_view” là một tham chiếu nhẹ đến chuỗi ký tự cơ bản của “originString” mà không sao chép dữ liệu.
Đây là đầu ra được tạo ra:
Ví dụ 2: Khả năng tương tác với Mã kế thừa
Trong lĩnh vực phát triển C++, việc tích hợp liền mạch các cơ sở mã mới và cũ thường là mối quan tâm hàng đầu. “std::string_view” cho phép các nhà phát triển tương tác dễ dàng với các hàm kế thừa trả về con trỏ “const char”.
Hãy xem xét ví dụ sau đây minh họa cách sử dụng thực tế của “std::string_view” cho khả năng tương tác. Ở đây, chúng ta có một hàm cũ có tên là “legacyFunction()” trả về một con trỏ “const char”:
#include#include
const char * di sảnChức năng ( ) {
trở lại 'Chuỗi kế thừa' ;
}
int chính ( ) {
std::string_view di sảnStrView ( di sảnChức năng ( ) ) ;
std::cout << 'Chế độ xem chuỗi kế thừa: ' << di sảnStrView << std::endl;
trở lại 0 ;
}
Chúng ta bắt đầu bằng cách xác định một hàm kế thừa có tên là “legacyFunction()” trả về một con trỏ “const char” đại diện cho một chuỗi được gắn nhãn là “Chuỗi kế thừa”. Để kết hợp liền mạch dữ liệu cũ này vào chương trình C++ hiện đại của chúng tôi, chúng tôi sử dụng “std::string_view”. Cụ thể, trong hàm main(), chúng ta tạo một phiên bản của “std::string_view” có tên là “legacyStrView” và khởi tạo nó với kết quả của hàm kế thừa. Việc khởi tạo này cho phép chúng ta đóng gói và làm việc một cách hiệu quả với con trỏ “const char” kế thừa.
Kết quả là chúng ta có thể truy cập và thao tác chuỗi kế thừa mà không cần dùng đến việc sao chép dữ liệu không cần thiết, duy trì cả tính hiệu quả và khả năng tương thích. Bước cuối cùng trong mã liên quan đến việc sử dụng “std::cout” để in nội dung của chế độ xem chuỗi cũ.
Đầu ra được thực hiện là:
Ví dụ 3: Xử lý chuỗi ký tự được cải thiện
Chuỗi ký tự trong C++ theo truyền thống được biểu diễn dưới dạng mảng ký tự. “std::string_view” đơn giản hóa việc làm việc với các chuỗi ký tự bằng cách cung cấp một giao diện thuận tiện. Bằng cách cho phép truy cập trực tiếp vào mảng ký tự cơ bản mà không cần chuyển đổi rõ ràng, “std::string_view” hợp lý hóa các hoạt động trên chuỗi ký tự.
#include#include
int chính ( ) {
const char * myLiteral = 'Xin chào, Chế độ xem chuỗi!' ;
std::string_view dạng chữView ( myLiteral ) ;
std::cout << 'Ký tự đầu tiên:' << theo nghĩa đenXem [ 0 ] << std::endl;
vị trí size_t = chữView.find ( 'Sợi dây' ) ;
std::cout << 'Vị trí chuỗi con:' << chức vụ << std::endl;
trở lại 0 ;
}
Trong ví dụ này là “Xin chào, Chế độ xem chuỗi!” chuỗi ký tự được gán cho con trỏ “myLiteral”. Việc giới thiệu “std::string_view” tạo điều kiện cho việc trình bày chuỗi này hiệu quả hơn mà không cần phải sao chép nội dung của nó. Đối tượng “literalView” được tạo bằng cách sử dụng con trỏ “myLiteral” cho phép chúng ta xem và thao tác với chuỗi ký tự cơ bản.
Việc sử dụng “std::string_view” giúp dễ dàng truy cập vào từng ký tự trong chuỗi. Trong đoạn mã, “literalView[0]” truy xuất và in ký tự đầu tiên của chuỗi, thể hiện sự đơn giản và trực tiếp của việc truy cập các phần tử. Phương thức “find” của “std::string_view” được sử dụng để xác định vị trí của chuỗi con “Chuỗi” trong chuỗi gốc.
Ví dụ 4: Trích xuất chuỗi con
Nhiệm vụ trích xuất chuỗi con liên quan đến việc truy xuất một phần của chuỗi đã cho dựa trên các tiêu chí đã chỉ định, chẳng hạn như vị trí của dấu phân cách. Khả năng trích xuất dễ dàng các chuỗi con là một tính năng mạnh mẽ của “std::string_view”. Hãy xem xét một tình huống trong đó chúng ta cần trích xuất một phần của chuỗi dựa trên dấu phân cách:
#include#include
int chính ( ) {
std::string fullString = 'táo-cam-chuối' ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , dấu phân cáchPos ) ;
std::cout << 'Chuỗi con được trích xuất:' << chuỗi con << std::endl;
trở lại 0 ;
}
Trong đoạn mã này, chúng ta bắt đầu bằng việc khai báo một chuỗi gốc, “fullString”, được khởi tạo bằng giá trị “apple-orange-banana”. Mục tiêu của chúng tôi là thực hiện trích xuất chuỗi con. Để đạt được điều này, chúng tôi sử dụng chức năng “tìm” do thư viện chuẩn C++ cung cấp.
Khi chúng tôi xác định vị trí của dấu phân cách trong “fullString”, được lưu trữ trong biến “delimiterPos”, chúng tôi sẽ trích xuất chuỗi con mong muốn. Hàm “substr” được gọi trên chuỗi gốc, chỉ định vị trí bắt đầu (0) và độ dài của chuỗi con chính xác là vị trí của dấu phân cách. Hoạt động này dẫn đến việc tạo ra “std::string_view” có tên là “subString” đại diện cho phần của chuỗi gốc từ đầu đến dấu phân cách.
Ví dụ 5: Cấu trúc dữ liệu hiệu quả về bộ nhớ
“std::string_view” đóng một vai trò quan trọng trong việc thiết kế cấu trúc dữ liệu hiệu quả về bộ nhớ. Thay vì lưu trữ nhiều bản sao của chuỗi, cấu trúc dữ liệu có thể lưu trữ các phiên bản “std::string_view”, do đó giảm chi phí bộ nhớ.
#include#include
bản ghi cấu trúc {
std::string_view tên;
int tuổi;
} ;
int chính ( ) {
Người ghi chép = { 'John Doe' , 30 } ;
std::cout << 'Tên: ' << người.name << ', Tuổi: ' << người.tuổi << std::endl;
trở lại 0 ;
}
Trong đoạn mã này, chúng tôi giới thiệu cách sử dụng “std::string_view” trong cấu trúc dữ liệu tiết kiệm bộ nhớ. Chúng tôi xác định cấu trúc “Bản ghi” bao gồm thành viên “std::string_view” có tên là “name” và thành viên số nguyên có tên là “age”. Việc sử dụng “std::string_view” trong ngữ cảnh này cho phép chúng ta tạo một biểu diễn nhẹ của chuỗi mà không cần cấp phát thêm bộ nhớ.
Trong hàm “chính”, chúng ta khởi tạo một đối tượng “Bản ghi” có tên “người” với tên “John Doe” và tuổi 30. “tên” thành viên “std::string_view” đóng vai trò là chế độ xem không sở hữu của dữ liệu ký tự tương ứng với tên, loại bỏ sự cần thiết phải sao chép nội dung chuỗi. “std::cout << “Tên: ” << user.name << “, Tuổi: ” << user.age << std::endl;” câu lệnh xuất ra tên và tuổi của người được lưu trữ trong đối tượng “Record”.
Phần kết luận
Trong bối cảnh phát triển C++ không ngừng phát triển, “std::string_view” nổi bật như một sự bổ sung có giá trị cho bộ công cụ của lập trình viên. Các trường hợp được minh họa trong bài viết này nêu bật khả năng thích ứng và tiện ích của “std::string_view” trong lĩnh vực lập trình C++. Từ thao tác chuỗi hiệu quả và khả năng tương tác liền mạch với mã kế thừa đến cấu trúc dữ liệu tiết kiệm bộ nhớ, “std::string_view” rất có giá trị đối với các nhà phát triển đang tìm kiếm hiệu suất nâng cao và mã được tối ưu hóa trong nhiều tình huống khác nhau. Các tình huống thực tế này minh họa cách “std::string_view” có thể tối ưu hóa mã, giảm chi phí bộ nhớ không cần thiết và góp phần nâng cao hiệu quả chung của các ứng dụng C++.