Tôi đã nghe một vài người bày tỏ lo lắng về toán tử "+" trong std :: string và các cách giải quyết khác nhau để tăng tốc độ nối. Có cái nào thực sự cần thiết không? Nếu vậy, cách tốt nhất để nối các chuỗi trong C ++ là gì?

Việc làm thêm chưa chắc đã đáng, trừ khi bạn thực sự cần sự hiệu quả. Bạn có thể sẽ có hiệu quả tốt hơn nhiều chỉ đơn giản bằng cách sử dụng toán tử + = thay thế.

Bây giờ sau tuyên bố từ chối trách nhiệm đó, tôi sẽ trả lời câu hỏi thực tế của bạn ...

Hiệu quả của lớp chuỗi STL phụ thuộc vào việc triển khai STL bạn đang sử dụng.

Bạn có thể đảm bảo hiệu quả và tự kiểm soát tốt hơn bằng cách thực hiện nối thủ công thông qua c chức năng tích hợp sẵn.

Tại sao toán tử + không hiệu quả:

Hãy xem giao diện này:

template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const basic_string<charT, traits, Alloc>& s2)

Bạn có thể thấy rằng một đối tượng mới được trả về sau mỗi dấu +. Điều đó có nghĩa là một bộ đệm mới được sử dụng mỗi lần. Nếu bạn đang thực hiện nhiều + hoạt động bổ sung thì nó không hiệu quả.

Tại sao bạn có thể làm cho nó hiệu quả hơn:

• Bạn đang đảm bảo tính hiệu quả thay vì tin tưởng một người được ủy quyền làm điều đó một cách hiệu quả cho bạn
• lớp std :: string không biết gì về kích thước tối đa của chuỗi của bạn, cũng như tần suất bạn sẽ nối với nó. Bạn có thể có kiến ​​thức này và có thể làm những việc dựa trên thông tin này. Điều này sẽ dẫn đến việc phân bổ lại ít hơn.
• Bạn sẽ kiểm soát bộ đệm theo cách thủ công để có thể chắc chắn rằng bạn sẽ không sao chép toàn bộ chuỗi vào bộ đệm mới khi bạn không muốn điều đó xảy ra.
• Bạn có thể sử dụng ngăn xếp cho bộ đệm của mình thay vì đống sẽ hiệu quả hơn nhiều.
• Toán tử string + sẽ tạo một đối tượng chuỗi mới và trả lại nó bằng cách sử dụng một bộ đệm mới.

Cân nhắc khi thực hiện:

• Theo dõi độ dài chuỗi.
• Giữ một con trỏ đến cuối chuỗi và bắt đầu, hoặc chỉ bắt đầu và sử dụng bắt đầu + độ dài làm phần bù để tìm phần cuối của chuỗi.
• Đảm bảo rằng bộ đệm bạn đang lưu trữ chuỗi của mình đủ lớn để bạn không cần phải phân bổ lại dữ liệu
• Sử dụng strcpy thay vì strcat để bạn không cần phải lặp qua độ dài của chuỗi để tìm phần cuối của chuỗi.

Cấu trúc dữ liệu dây:

Nếu bạn cần nối thực sự nhanh, hãy xem xét sử dụng cấu trúc dữ liệu dây .

Đặt trước không gian cuối cùng của bạn, sau đó sử dụng phương thức nối thêm với bộ đệm. Ví dụ: giả sử bạn mong đợi độ dài chuỗi cuối cùng của mình là 1 triệu ký tự:

std::string s;
s.reserve(1000000);

while (whatever)
{
  s.append(buf,len);
}

Tôi sẽ không lo lắng về nó. Nếu bạn làm điều đó trong một vòng lặp, các chuỗi sẽ luôn phân bổ trước bộ nhớ để giảm thiểu việc phân bổ lại - chỉ sử dụng operator+=trong trường hợp đó. Và nếu bạn làm điều đó theo cách thủ công, tương tự như thế này hoặc lâu hơn

a + " : " + c

Sau đó, nó tạo ra thời gian tạm thời - ngay cả khi trình biên dịch có thể loại bỏ một số bản sao giá trị trả về. Đó là bởi vì trong một lần gọi liên tiếp, operator+nó không biết liệu tham số tham chiếu có tham chiếu đến một đối tượng được đặt tên hay tạm thời được trả về từ một lệnh operator+gọi con hay không . Tôi không muốn lo lắng về nó trước khi không có hồ sơ đầu tiên. Nhưng hãy lấy một ví dụ cho thấy điều đó. Đầu tiên chúng tôi giới thiệu dấu ngoặc đơn để làm rõ ràng ràng buộc. Tôi đặt các đối số ngay sau khai báo hàm được sử dụng để làm rõ ràng. Dưới đó, tôi hiển thị biểu thức kết quả sau đó là:

((a + " : ") + c) 
calls string operator+(string const&, char const*)(a, " : ")
  => (tmp1 + c)

Bây giờ, thêm vào đó, tmp1là những gì được trả về bởi cuộc gọi đầu tiên tới toán tử + với các đối số được hiển thị. Chúng tôi cho rằng trình biên dịch thực sự thông minh và tối ưu hóa bản sao giá trị trả về. Vì vậy, chúng tôi kết thúc với một chuỗi mới chứa nối của avà " : ". Bây giờ, điều này xảy ra:

(tmp1 + c)
calls string operator+(string const&, string const&)(tmp1, c)
  => tmp2 == <end result>

So sánh điều đó với những điều sau:

std::string f = "hello";
(f + c)
calls string operator+(string const&, string const&)(f, c)
  => tmp1 == <end result>

Nó sử dụng cùng một hàm cho một chuỗi tạm thời và cho một chuỗi được đặt tên! Vì vậy, các trình biên dịch có để sao chép các đối số vào một chuỗi mới và append vào đó và gửi lại cho ra khỏi cơ thể của operator+. Nó không thể lấy bộ nhớ của một tạm thời và thêm vào đó. Biểu thức càng lớn thì càng phải thực hiện nhiều bản sao của chuỗi.

Tiếp theo Visual Studio và GCC sẽ hỗ trợ ngữ nghĩa di chuyển của c ++ 1x (bổ sung ngữ nghĩa sao chép ) và các tham chiếu rvalue như một bổ sung thử nghiệm. Điều đó cho phép tìm hiểu xem tham số có tham chiếu tạm thời hay không. Điều này sẽ làm cho những bổ sung như vậy nhanh chóng đáng kinh ngạc, vì tất cả những điều trên sẽ kết thúc trong một "đường ống bổ sung" mà không có bản sao.

Nếu nó trở thành một nút cổ chai, bạn vẫn có thể làm

 std::string(a).append(" : ").append(c) ...

Các appendlệnh gọi nối đối số vào *thisvà sau đó trả về một tham chiếu cho chính chúng. Vì vậy, không có việc sao chép thời gian tạm thời được thực hiện ở đó. Hoặc cách khác, operator+=có thể được sử dụng, nhưng bạn sẽ cần dấu ngoặc đơn xấu xí để sửa mức độ ưu tiên.

Đối với hầu hết các ứng dụng, nó sẽ không thành vấn đề. Chỉ cần viết mã của bạn, vui mừng không biết chính xác cách hoạt động của toán tử + và chỉ giải quyết vấn đề của bạn nếu nó trở thành một nút cổ chai rõ ràng.

Không giống như .NET System.Strings, chuỗi std :: của C ++ có thể thay đổi được và do đó có thể được xây dựng thông qua phép nối đơn giản cũng nhanh như thông qua các phương thức khác.

có lẽ std :: stringstream thay thế?

Nhưng tôi đồng ý với quan điểm rằng bạn có thể chỉ nên giữ cho nó có thể duy trì được và dễ hiểu, sau đó lập hồ sơ để xem liệu bạn có thực sự gặp vấn đề hay không.

Trong Imperfect C ++ , Matthew Wilson trình bày một trình nối chuỗi động tính toán trước độ dài của chuỗi cuối cùng để chỉ có một phân bổ trước khi nối tất cả các phần. Chúng ta cũng có thể triển khai một trình nối tĩnh bằng cách chơi với các mẫu biểu thức .

Loại ý tưởng đó đã được thực hiện trong triển khai STLport std :: string - điều đó không phù hợp với tiêu chuẩn vì vụ hack chính xác này.

std::string operator+phân bổ một chuỗi mới và sao chép hai chuỗi toán hạng mỗi lần. lặp lại nhiều lần và nó trở nên đắt đỏ, O (n).

std::string appendvà operator+=mặt khác, tăng dung lượng lên 50% mỗi khi chuỗi cần phát triển. Điều này làm giảm đáng kể số lần cấp phát bộ nhớ và hoạt động sao chép, O (log n).

Đối với dây nhỏ thì không thành vấn đề. Nếu bạn có các chuỗi lớn, bạn nên lưu trữ chúng dưới dạng vector hoặc trong một số bộ sưu tập khác dưới dạng các bộ phận. Và thêm thuật toán của bạn để làm việc với tập dữ liệu như vậy thay vì một chuỗi lớn.

Tôi thích std :: ostringstream để nối phức tạp.

Như với hầu hết mọi thứ, không làm điều gì đó dễ hơn làm.

Nếu bạn muốn xuất các chuỗi lớn sang GUI, có thể là bất cứ thứ gì bạn đang xuất ra có thể xử lý các chuỗi thành từng phần tốt hơn là một chuỗi lớn (ví dụ: nối văn bản trong trình soạn thảo văn bản - thường chúng giữ các dòng riêng biệt cấu trúc).

Nếu bạn muốn xuất ra một tệp, hãy truyền dữ liệu trực tuyến thay vì tạo một chuỗi lớn và xuất ra.

Tôi chưa bao giờ thấy cần phải làm cho việc nối nhanh hơn cần thiết nếu tôi đã loại bỏ sự nối không cần thiết khỏi mã chậm.

Có thể là hiệu suất tốt nhất nếu bạn phân bổ trước (dự trữ) không gian trong chuỗi kết quả.

template<typename... Args>
std::string concat(Args const&... args)
{
    size_t len = 0;
    for (auto s : {args...})  len += strlen(s);

    std::string result;
    result.reserve(len);    // <--- preallocate result
    for (auto s : {args...})  result += s;
    return result;
}

Sử dụng:

std::string merged = concat("This ", "is ", "a ", "test!");

Một mảng ký tự đơn giản, được đóng gói trong một lớp giúp theo dõi kích thước mảng và số byte được phân bổ là nhanh nhất.

Bí quyết là chỉ thực hiện một phân bổ lớn khi bắt đầu.

tại

https://github.com/pedro-vicente/table-string

Điểm chuẩn

Đối với Visual Studio 2015, xây dựng gỡ lỗi x86, cải tiến cơ bản về C ++ std :: string.

| API                   | Seconds           
| ----------------------|----| 
| SDS                   | 19 |  
| std::string           | 11 |  
| std::string (reserve) | 9  |  
| table_str_t           | 1  |  

Bạn có thể thử cái này với bộ nhớ đặt trước cho từng món:

namespace {
template<class C>
constexpr auto size(const C& c) -> decltype(c.size()) {
  return static_cast<std::size_t>(c.size());
}

constexpr std::size_t size(const char* string) {
  std::size_t size = 0;
  while (*(string + size) != '\0') {
    ++size;
  }
  return size;
}

template<class T, std::size_t N>
constexpr std::size_t size(const T (&)[N]) noexcept {
  return N;
}
}

template<typename... Args>
std::string concatStrings(Args&&... args) {
  auto s = (size(args) + ...);
  std::string result;
  result.reserve(s);
  return (result.append(std::forward<Args>(args)), ...);
}