Birkaç kişinin std :: string'de "+" operatörü ve birleştirme işlemini hızlandırmak için çeşitli geçici çözümler hakkında endişelerini dile getirdiğini duydum. Bunlardan herhangi biri gerçekten gerekli mi? Öyleyse, dizeleri C ++ 'da birleştirmenin en iyi yolu nedir?

Gerçekten verimliliğe ihtiyacınız olmadıkça fazladan çalışmaya muhtemelen değmez. Bunun yerine + = operatörünü kullanarak muhtemelen çok daha iyi bir verim elde edeceksiniz.

Şimdi bu feragatnameden sonra, asıl sorunuzu cevaplayacağım ...

STL dizgi sınıfının verimliliği, kullandığınız STL'nin uygulanmasına bağlıdır.

Yerleşik c işlevler aracılığıyla manuel olarak birleştirme yaparak verimliliği garanti edebilir ve daha fazla kontrole sahip olabilirsiniz .

Operatör + neden verimli değil:

Şu arayüze bir göz atın:

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)

Her + 'dan sonra yeni bir nesnenin döndürüldüğünü görebilirsiniz. Bu, her seferinde yeni bir arabellek kullanıldığı anlamına gelir. Bir ton ekstra + işlem yapıyorsanız bu verimli değildir.

Neden daha verimli hale getirebilirsiniz:

• Bir temsilcinin bunu sizin için verimli bir şekilde yapacağına güvenmek yerine verimliliği garanti ediyorsunuz
• std :: string sınıfı, dizginizin maksimum boyutu hakkında hiçbir şey bilmiyor, ne sıklıkta dizgenizi birleştiriyor olacaksınız. Bu bilgiye sahip olabilirsiniz ve bu bilgilere dayanarak bir şeyler yapabilirsiniz. Bu, daha az yeniden tahsis yapılmasına yol açacaktır.
• Arabellekleri manuel olarak kontrol edeceksiniz, böylece bunun olmasını istemediğinizde tüm dizeyi yeni arabelleklere kopyalamayacağınızdan emin olabilirsiniz.
• Yığını, çok daha verimli olan yığın yerine tamponlarınız için kullanabilirsiniz.
• string + operatörü yeni bir string nesnesi yaratacak ve onu yeni bir tampon kullanarak geri döndürecektir.

Uygulama için dikkat edilmesi gerekenler:

• İp uzunluğunu takip edin.
• Bir göstericiyi dizenin sonunda ve başlangıcında veya sadece başlangıcında tutun ve dizenin sonunu bulmak için bir uzaklık olarak başlangıç ​​+ uzunluğu kullanın.
• Dizenizi sakladığınız arabelleğin yeterince büyük olduğundan emin olun, böylece verileri yeniden ayırmanıza gerek kalmaz.
• Dizenin sonunu bulmak için dizenin uzunluğu boyunca yineleme yapmanıza gerek kalmaması için strcat yerine strcpy kullanın.

Halat veri yapısı:

Gerçekten hızlı birleştirme işlemlerine ihtiyacınız varsa, bir halat veri yapısı kullanmayı düşünün .

Daha önce son alanınızı ayırın, ardından ekleme yöntemini bir tamponla kullanın. Örneğin, son dize uzunluğunuzun 1 milyon karakter olmasını beklediğinizi varsayalım:

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

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

Bununla endişelenmek istemem. Bunu bir döngü içinde yaparsanız, dizeler yeniden tahsisleri en aza indirmek için her zaman belleği önceden tahsis eder - sadece operator+=bu durumda kullanın . Ve manuel olarak yaparsanız, bunun gibi veya daha uzun

a + " : " + c

Sonra, derleyici bazı dönüş değeri kopyalarını eleyebilse bile geçiciler yaratıyor. Bunun nedeni, art arda çağrılmasında operator+, referans parametresinin adlandırılmış bir nesneye mi yoksa bir alt çağırmadan geçici olarak döndürülen bir nesneye mi başvurduğunu bilmemesidir operator+. İlk önce profil oluşturmadan endişelenmemeyi tercih ederim. Ama bunu göstermek için bir örnek alalım. Bağlamayı açıklığa kavuşturmak için önce parantez kullanıyoruz. Açıklık için kullanılan işlev bildiriminin hemen arkasına argümanları koyuyorum. Bunun altında, ortaya çıkan ifadenin ne olduğunu gösteriyorum:

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

Şimdi, bu ek olarak, tmp1gösterilen argümanlarla + operatörüne yapılan ilk çağrı tarafından döndürülen şeydir. Derleyicinin gerçekten akıllı olduğunu ve dönüş değeri kopyasını optimize ettiğini varsayıyoruz. Bu yüzden concatenation içeren tek bir yeni dize ile bitirmek ave " : ". Şimdi, bu olur:

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

Bunu şununla karşılaştırın:

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

Aynı işlevi geçici ve adlandırılmış bir dizge için kullanıyor! Yani derleyici sahip olduğu için yeni bir dizeye ve ekleme yapılması halinde argüman kopyalayıp gövdesinden iade etmek operator+. Bir geçicinin anısını alıp ona ekleyemez. İfade ne kadar büyükse, dizelerin o kadar çok kopyasının yapılması gerekir.

Sonraki Visual Studio ve GCC, c ++ 1x'in taşıma semantiğini ( kopya semantiğini tamamlayan ) ve deneysel bir ekleme olarak rvalue referanslarını destekleyecektir. Bu, parametrenin geçici olup olmadığını anlamaya izin verir. Bu, bu tür eklemeleri inanılmaz derecede hızlı hale getirecektir, çünkü yukarıdakilerin tümü kopyasız bir "eklenti hattı" ile sonuçlanacaktır.

Bir darboğaz olduğu ortaya çıkarsa, yine de yapabilirsiniz

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

appendÇağrılar için argüman eklemek *thisve daha sonra kendilerine bir başvuru döndürür. Yani orada geçicilerin kopyalanması yapılmaz. Veya alternatif operator+=olarak kullanılabilir, ancak önceliği düzeltmek için çirkin parantezlere ihtiyacınız olacaktır.

Çoğu uygulama için önemli olmayacak. Sadece + operatörünün tam olarak nasıl çalıştığını bilmeden kodunuzu yazın ve yalnızca belirgin bir darboğaz haline gelirse sorunları kendi ellerinize alın.

.NET System.Strings aksine, C ++ 'ın std :: dizeleri olan değişken ve bu nedenle basit dizilim yoluyla kadar hızlı gibi diğer yöntemlerle inşa edilebilir.

bunun yerine belki std :: stringstream?

Ancak, muhtemelen sadece sürdürülebilir ve anlaşılır tutmanız ve ardından gerçekten sorun yaşayıp yaşamadığınızı görmek için profil çıkarmanız gerektiği düşüncesine katılıyorum.

In Kusurlu C ++ , Matthew Wilson sunar dinamik tüm parçaları birleştirerek önce tek tahsisi sahip olmak için son dize uzunluğunu önceden hesaplar olduğunu dize Concatenator. İfade şablonlarıyla oynayarak da statik bir birleştirici uygulayabiliriz .

Bu tür bir fikir STLport std :: string uygulamasında uygulandı - bu kesin hack nedeniyle standarda uymuyor.

std::string operator+yeni bir dizge ayırır ve her seferinde iki işlenen dizgiyi kopyalar. birçok kez tekrarlayın ve pahalı hale gelir, O (n).

std::string appendve operator+=diğer yandan, dizinin her büyümesi gerektiğinde kapasiteyi% 50 arttırın. Bellek ayırma ve kopyalama işlemlerinin sayısını önemli ölçüde azaltan, O (log n).

Küçük dizeler için önemli değil. Büyük dizeleriniz varsa, onları vektörde oldukları gibi veya başka bir koleksiyonda parça olarak saklamanız daha iyi olur. Ve algoritmanızı tek bir büyük dizgi yerine böyle bir veri kümesiyle çalışacak şekilde ekleyin.

Karmaşık birleştirme için std :: ostringstream'i tercih ederim.

Çoğu şeyde olduğu gibi, bir şeyi yapmamak, yapmaktan daha kolaydır.

Bir GUI'ye büyük dizeler çıkarmak istiyorsanız, çıktısını aldığınız her şey, dizeleri büyük bir dizeden daha iyi işleyebilir (örneğin, bir metin düzenleyicide metni birleştirme - genellikle satırları ayrı tutarlar) yapılar).

Bir dosyaya çıktı vermek istiyorsanız, büyük bir dize oluşturmak ve bunu çıkarmak yerine verileri akışa alın.

Yavaş koddan gereksiz birleştirmeyi kaldırırsam, daha hızlı birleştirme ihtiyacını asla bulamadım.

Ortaya çıkan dizede alanı önceden ayırırsanız (ayırırsanız) muhtemelen en iyi performans.

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;
}

Kullanım:

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

Dizi boyutunu ve ayrılan bayt sayısını izleyen bir sınıfta kapsüllenmiş basit bir karakter dizisi en hızlısıdır.

İşin püf noktası, başlangıçta yalnızca bir büyük tahsisat yapmaktır.

-de

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

Kıyaslamalar

Visual Studio 2015 için, x86 hata ayıklama derlemesi, C ++ std :: string üzerinde önemli iyileştirme.

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

Bunu her öğe için bellek ayırmalarıyla deneyebilirsiniz:

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)), ...);
}