Const std :: string & parametrelerini geçen günler parametre olarak mı?

Herb Sutter tarafından geçen std::vectorve geçen nedenlerin büyük ölçüde gittiğini öneren bir konuşma duydum . Aşağıdaki gibi bir işlev yazmanın artık tercih edilebilir olduğunu öne sürdü:std::stringconst &

std::string do_something ( std::string inval )
{
   std::string return_val;
   // ... do stuff ...
   return return_val;
}

return_valİşlevin döndüğü noktada bir rvalue olacağını ve bu nedenle çok ucuz olan hareket semantiği kullanılarak döndürülebileceğini anlıyorum . Bununla birlikte, invalhala bir referansın boyutundan çok daha büyüktür (genellikle bir işaretçi olarak uygulanır). Bunun nedeni std::string, a'nın öbeğe bir işaretçi ve char[]kısa dize optimizasyonu için bir üye dahil olmak üzere çeşitli bileşenlere sahip olmasıdır . Bana öyle geliyor ki, referansla geçmenin hala iyi bir fikir olduğu anlaşılıyor.

Herb neden bunu söylemiş olabilir?

Herb'in söylediklerinin nedeni bu gibi durumlar.

Diyelim ki işlevi Açağıran bir işlevim var B, işlevi çağıran C. Ve Abir ipi içine Bve içine geçirir C. Abilmiyor veya önemsemiyor C; hakkında her şey Abilir B. Yani, Cbir uygulama detayıdır B.

A'nın aşağıdaki gibi tanımlandığını varsayalım:

void A()
{
  B("value");
}

B ve C dizeyi alırsa const&, şöyle görünür:

void B(const std::string &str)
{
  C(str);
}

void C(const std::string &str)
{
  //Do something with `str`. Does not store it.
}

Her şey yolunda ve güzel. Sadece işaretçiler geçiyorsunuz, kopyalama yok, hareket yok, herkes mutlu. Calır const&çünkü dizeyi saklamaz. Sadece kullanır.

Şimdi, basit bir değişiklik yapmak istiyorum: Cdizeyi bir yerde saklamak gerekiyor.

void C(const std::string &str)
{
  //Do something with `str`.
  m_str = str;
}

Merhaba, kopya oluşturucu ve potansiyel bellek ayırma ( Kısa Dize Optimizasyonu (SSO) yoksay ). C ++ 11'in hareket semantiği gereksiz kopya oluşturmayı kaldırmayı mümkün kılıyor, değil mi? Ve Ageçici geçiyor; verileri kopyalamakC zorunda olmanız için hiçbir neden yoktur . Ona verilen şeyden kaçınmalı.

Dışında olamaz. Çünkü bir const&.

Eğer Cparametresini değere göre değiştirirsem , bu sadece Bbu parametreye kopyalamaya neden olur ; Hiçbir şey kazanmıyorum.

Bu yüzden str, tüm fonksiyonlar boyunca değerden geçmiş olsaydım std::move, verileri karıştırmaya güveniyor olsaydım , bu problemimiz olmazdı. Birisi ona tutunmak istiyorsa, yapabilir. Eğer yapmazlarsa, oh iyi.

Daha mı pahalı? Evet; bir değere geçmek referans kullanmaktan daha pahalıdır. Kopyadan daha ucuz mu? TOA içeren küçük teller için değil. Yapmaya değer mi?

Kullanım durumunuza bağlıdır. Bellek ayırmalarından ne kadar nefret ediyorsunuz?

Const std :: string & parametrelerini geçen günler parametre olarak mı?

Hayır . Birçok kişi bu tavsiyeyi (Dave Abrahams dahil) uygulandığı alan adının ötesine taşır ve tüm std::string parametrelere uygulanmasını basitleştirir - Her zamanstd::string değerden geçmek , keyfi parametreler ve uygulamalar için her zaman "en iyi uygulama" değildir çünkü optimizasyonlar görüşmeler / makaleler sadece sınırlı sayıda vaka için geçerlidir .

Bir değer döndürüyorsanız, parametreyi değiştiriyorsanız veya değeri alıyorsanız, değere göre geçmek pahalı kopyalamayı kurtarabilir ve sözdizimi kolaylığı sağlayabilir.

Her zamanki gibi, const referansından geçmek, bir kopyaya ihtiyacınız olmadığında çok fazla kopyadan tasarruf sağlar .

Şimdi özel örneğe bakalım:

Bununla birlikte, inval hala bir referansın boyutundan (genellikle bir işaretçi olarak uygulanır) çok daha büyüktür. Bunun nedeni, bir std :: string'in, öbeğe bir işaretçi ve kısa dize optimizasyonu için bir üye char [] dahil çeşitli bileşenlere sahip olmasıdır. Bana öyle geliyor ki, referansla geçmenin hala iyi bir fikir olduğu anlaşılıyor. Herb neden bunu söylemiş olabilir?

Yığın boyutu bir endişe ise (ve bunun satır içi / optimize edilmediğini varsayarak), return_val+ inval> return_val- IOW ise, pik yığın kullanımı, değere buradan geçirilerek azaltılabilir (not: ABI'lerin aşırı basitleştirilmesi). Bu arada, const referansı ile geçmek optimizasyonları devre dışı bırakabilir. Buradaki ana neden, yığın büyümesini önlemek değil, optimizasyonun uygulanabilir olduğu yerde gerçekleştirilebilmesini sağlamaktır .

Const referansı ile geçen günler bitmedi - kurallar eskisinden daha karmaşık. Performans önemliyse, uygulamalarınızda kullandığınız ayrıntılara dayanarak bu türleri nasıl geçireceğinizi düşünmek akıllıca olacaktır.

Bu büyük ölçüde derleyicinin uygulamasına bağlıdır.

Ancak, ne kullandığınıza da bağlıdır.

Bir sonraki fonksiyonları ele alalım:

bool foo1( const std::string v )
{
  return v.empty();
}
bool foo2( const std::string & v )
{
  return v.empty();
}

Bu işlevler, satır içi çizgiden kaçınmak için ayrı bir derleme biriminde uygulanır. O zaman:
1. Eğer bu iki fonksiyona gerçek bir bilgi aktarırsanız, performanslarda fazla bir fark görmezsiniz. Her iki durumda da, bir dize nesnesi oluşturulmalıdır
2. Başka bir std :: string nesnesi iletirseniz, foo2daha iyi performans gösterir foo1, çünkü foo1derin bir kopya yapar.

Bilgisayarımda g ++ 4.6.1 kullanarak şu sonuçları aldım:

• referans ile değişken: 1000000000 iterasyon -> geçen süre: 2.25912 sn
• değere göre değişken: 1000000000 iterasyon -> geçen süre: 27.2259 sn
• referans ile değişmez değer: 100000000 iterasyon -> geçen süre: 9.10319 sn
• değere göre değişmez değer: 100000000 iterasyon -> geçen süre: 8.62659 sn

Kısa cevap: HAYIR! Uzun cevap:

• Dizeyi değiştirmezseniz (tedavi salt okunurdur), olarak iletin const ref&.
  ( const ref&Açıkçası onu kullanan işlev yürütülürken kapsam dahilinde kalmalıdır)
• Değiştirmeyi planlıyorsanız veya kapsam dışına çıkacağını biliyorsanız (iş parçacıkları) , a olarak iletin , işlev gövdesinin içini valuekopyalamayın const ref&.

Üzerinde bir post vardı cpp-next.com denilen "istiyor hız değeriyle geçmesi," . TL; DR:

Yönerge : İşlev argümanlarınızı kopyalamayın. Bunun yerine, bunları değere göre iletin ve derleyicinin kopyalamayı yapmasına izin verin.

ÇEVİRİ ^

İşlev argümanlarınızı kopyalamayın --- şu anlama gelir: bağımsız değişken değerini dahili bir değişkene kopyalayarak değiştirmeyi planlıyorsanız, bunun yerine bir değer bağımsız değişkeni kullanın .

Yani, bunu yapma :

std::string function(const std::string& aString){
    auto vString(aString);
    vString.clear();
    return vString;
}

bunu yap :

std::string function(std::string aString){
    aString.clear();
    return aString;
}

İşlev gövdesindeki bağımsız değişken değerini değiştirmeniz gerektiğinde.

Sadece bağımsız değişkeni işlev gövdesinde nasıl kullanmayı planladığınızın farkında olmanız gerekir. Salt okunur veya DEĞİL ... ve kapsama alanı içinde kalırsa.

Aslında bir kopyaya ihtiyacınız olmadığı sürece çekilmesi makul olur const &. Örneğin:

bool isprint(std::string const &s) {
    return all_of(begin(s),end(s),(bool(*)(char))isprint);
}

Dizeyi değere göre alacak şekilde değiştirirseniz, parametreyi taşıyabilir veya kopyalayabilirsiniz ve buna gerek yoktur. Kopyalama / taşıma sadece daha pahalı olmakla kalmaz, aynı zamanda yeni bir potansiyel arıza da getirir; kopyalama / taşıma bir istisna fırlatabilir (örn. kopyalama sırasında ayırma başarısız olabilir), ancak mevcut bir değere referans almak mümkün değildir.

Eğer varsa do kopyası gerekiyor sonra geçen ve değeri ile dönen genellikle (her zaman?) En iyi seçenek. Aslında, ekstra kopyaların aslında bir performans sorununa neden olduğunu bulamazsanız genellikle C ++ 03'te endişelenmeyeceğim. Kopya seçimleri modern derleyicilerde oldukça güvenilir görünüyor. İnsanların RVO için derleyici desteği tablonuzu kontrol etmeniz gerektiğine dair şüpheleri ve ısrarları, günümüzde çoğunlukla eski.

Kısacası, C ++ 11, kopya seçimine güvenmeyen insanlar dışında bu konuda hiçbir şeyi gerçekten değiştirmez.

Neredeyse.

C ++ 17'de, parametreler basic_string_view<?>için bizi temel olarak bir dar kullanım durumuna std::string const&indirir.

Hareket semantiğinin varlığı, bir kullanım örneğini ortadan kaldırmıştır std::string const&- eğer parametreyi saklamayı planlıyorsanız, parametrenin dışında std::stringolabildiğince bir by değeri almak daha uygundur move.

Birisi ham C ile fonksiyonunuzu çağırdıysa, bu durumda iki "string"tanesinin std::stringaksine sadece bir tampon tahsis edilir std::string const&.

Ancak, bir kopya yapmak istemiyorsanız std::string const&, C ++ 14'te yine de yararlıdır.

Bununla birlikte std::string_view, söz konusu dizeyi C stili '\0'sonlandırılmış karakter arabellekleri bekleyen bir API'ye geçirmediğiniz sürece, std::stringherhangi bir ayırma riski olmadan işlevsellik gibi daha verimli bir şekilde alabilirsiniz . İşlenmemiş bir C dizesi, std::string_viewherhangi bir ayırma veya karakter kopyalama olmadan bir 'e dönüştürülebilir .

Bu noktada, std::string const&veri toptan satışını kopyalamadığınızda ve boş bir sonlandırılmış arabellek bekleyen bir C stili API'ye geçireceğiniz ve bunun için daha yüksek düzeyli dize işlevlerine ihtiyacınız olacak std::string. Uygulamada, bu nadir bir gereksinim kümesidir.

std::stringdeğil Düz Eski Verileri (POD) ve ham boyutu şimdiye kadarki en alakalı bir şey değildir. Örneğin, TOA uzunluğunun üzerinde olan ve öbek üzerinde ayrılan bir dize iletirseniz, kopya oluşturucunun SSO depolamasını kopyalamamasını beklerim.

Bunun önerilmesinin nedeni inval, argüman ifadesinden yapılmış olması ve bu nedenle her zaman uygun şekilde taşınması veya kopyalanmasıdır - argümanın sahipliğine ihtiyacınız olduğunu varsayarsak performans kaybı olmaz. Bunu yapmazsanız, constbaşvuru yine de daha iyi bir yol olabilir.

Bu sorunun cevabını buraya kopyaladım / yapıştırdım ve isimleri ve yazımı bu soruya uyacak şekilde değiştirdim.

Sorulan soruları ölçmek için kod:

#include <iostream>

struct string
{
    string() {}
    string(const string&) {std::cout << "string(const string&)\n";}
    string& operator=(const string&) {std::cout << "string& operator=(const string&)\n";return *this;}
#if (__has_feature(cxx_rvalue_references))
    string(string&&) {std::cout << "string(string&&)\n";}
    string& operator=(string&&) {std::cout << "string& operator=(string&&)\n";return *this;}
#endif

};

#if PROCESS == 1

string
do_something(string inval)
{
    // do stuff
    return inval;
}

#elif PROCESS == 2

string
do_something(const string& inval)
{
    string return_val = inval;
    // do stuff
    return return_val; 
}

#if (__has_feature(cxx_rvalue_references))

string
do_something(string&& inval)
{
    // do stuff
    return std::move(inval);
}

#endif

#endif

string source() {return string();}

int main()
{
    std::cout << "do_something with lvalue:\n\n";
    string x;
    string t = do_something(x);
#if (__has_feature(cxx_rvalue_references))
    std::cout << "\ndo_something with xvalue:\n\n";
    string u = do_something(std::move(x));
#endif
    std::cout << "\ndo_something with prvalue:\n\n";
    string v = do_something(source());
}

Benim için bu çıktılar:

$ clang++ -std=c++11 -stdlib=libc++ -DPROCESS=1 test.cpp
$ a.out
do_something with lvalue:

string(const string&)
string(string&&)

do_something with xvalue:

string(string&&)
string(string&&)

do_something with prvalue:

string(string&&)
$ clang++ -std=c++11 -stdlib=libc++ -DPROCESS=2 test.cpp
$ a.out
do_something with lvalue:

string(const string&)

do_something with xvalue:

string(string&&)

do_something with prvalue:

string(string&&)

Aşağıdaki tablo sonuçlarımı özetler (clang -std = c ++ 11 kullanarak). İlk sayı kopya yapı sayısı ve ikinci sayı taşıma yapı sayısıdır:

+----+--------+--------+---------+
|    | lvalue | xvalue | prvalue |
+----+--------+--------+---------+
| p1 |  1/1   |  0/2   |   0/1   |
+----+--------+--------+---------+
| p2 |  1/0   |  0/1   |   0/1   |
+----+--------+--------+---------+

Geçiş değeri çözümü yalnızca bir aşırı yük gerektirir, ancak değer ve x değerlerini geçerken ek bir hareket yapısına mal olur. Bu, herhangi bir durum için kabul edilebilir veya olmayabilir. Her iki çözümün de avantajları ve dezavantajları vardır.

Herb Sutter, const std::string&parametre tipi olarak tavsiye edilirken , Bjarne Stroustroup ile birlikte hala kayıt altındadır ; görmek https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rf-in .

Buradaki diğer cevapların hiçbirinde belirtilmeyen bir tuzak vardır: bir const std::string&parametreye değişmez bir dize iletirseniz , değişmez karakterleri tutmak için anında oluşturulan geçici bir dizeye bir başvuru iletir. Daha sonra bu başvuruyu kaydederseniz, geçici dize ayrıldıktan sonra geçersiz olur. Güvende olmak için referansı değil bir kopyasını kaydetmelisiniz . Sorun, dizgi değişmezlerinin const char[N]terfi gerektiren türler olmasından kaynaklanmaktadır std::string.

Aşağıdaki kod, küçük bir verimlilik seçeneğiyle birlikte tuzak ve geçici çözümü gösterir - bir const char*yöntemle aşırı yükleme , , C ++ 'da referans olarak bir dizgi hazır bilgisini geçirmenin bir yolu var mı ?

(Not: Sutter & Stroustroup, dizenin bir kopyasını saklıyorsanız, && parametresi ve std :: move () ile aşırı yüklenmiş bir işlev sağlamanızı önerir.)

#include <string>
#include <iostream>
class WidgetBadRef {
public:
    WidgetBadRef(const std::string& s) : myStrRef(s)  // copy the reference...
    {}

    const std::string& myStrRef;    // might be a reference to a temporary (oops!)
};

class WidgetSafeCopy {
public:
    WidgetSafeCopy(const std::string& s) : myStrCopy(s)
            // constructor for string references; copy the string
    {std::cout << "const std::string& constructor\n";}

    WidgetSafeCopy(const char* cs) : myStrCopy(cs)
            // constructor for string literals (and char arrays);
            // for minor efficiency only;
            // create the std::string directly from the chars
    {std::cout << "const char * constructor\n";}

    const std::string myStrCopy;    // save a copy, not a reference!
};

int main() {
    WidgetBadRef w1("First string");
    WidgetSafeCopy w2("Second string"); // uses the const char* constructor, no temp string
    WidgetSafeCopy w3(w2.myStrCopy);    // uses the String reference constructor
    std::cout << w1.myStrRef << "\n";   // garbage out
    std::cout << w2.myStrCopy << "\n";  // OK
    std::cout << w3.myStrCopy << "\n";  // OK
}

ÇIKTI:

const char * constructor
const std::string& constructor

Second string
Second string

C ++ referansını kullanan IMO std::stringhızlı ve kısa bir yerel optimizasyondur, değerden geçerken kullanmak daha iyi bir global optimizasyon olabilir (veya olmayabilir).

Cevap: koşullara bağlı:

1. Tüm kodu dışarıdan iç fonksiyonlara yazarsanız, kodun ne yaptığını bilirsiniz, referansı kullanabilirsiniz const std::string &.
2. Kütüphane kodunu yazarsanız veya dizelerin geçtiği yerlerde yoğun kütüphane kodu kullanırsanız, std::stringkopya oluşturucu davranışına güvenerek küresel anlamda daha fazla kazanç elde edersiniz .

Bkz Modern C ++ Stil Temelleri! Essentials “Herb Sutter "Geri” . Diğer konular arasında, o C ++ 11 ile gelir ve spesifik olarak bakar, geçmişte verilmiş bulunuyor parametre aktararak, öneri ve yeni fikirler gözden dizeleri değere göre geçirme fikri.

Karşılaştırmalar std::string, işlevin yine de kopyalayacağı durumlarda, değere göre geçmenin önemli ölçüde daha yavaş olabileceğini göstermektedir!

Bunun nedeni, const&sürümü her zaman tam bir kopya oluşturmaya zorlamanızdır (ve daha sonra yerine taşıyın), sürüm zaten tahsis edilen arabelleği yeniden kullanabilen eski dizeyi güncelleyecektir.

Bkz. Slaydı 27: “Ayar” işlevleri için seçenek 1 her zamanki gibi aynıdır. Seçenek 2, rvalue referansı için aşırı yük ekler, ancak bu, birden fazla parametre varsa birleşik bir patlama sağlar.

Yalnızca, bir dizenin oluşturulması gereken (mevcut değerinin değiştirilmemesi gereken) “batma” parametreleri için, değere göre geçiş numarasının geçerli olması gerekir. Yani, inşaatçılar parametrenin doğrudan eşleşen türün üyesini başlattığı .

Bu konuda endişelenmeye ne kadar derin gidebileceğinizi görmek istiyorsanız, Nicolai Josuttis'in sunumunu ve bununla iyi şanslar izleyin ( önceki sürümde hata bulduktan sonra n kez “Mükemmel - Bitti!” . Hiç orada mıydınız ?)

Bu ayrıca Standart Kılavuzlarda inF.15 olarak özetlenmiştir .

@ JDługosz'un yorumlarda belirttiği gibi, Herb başka bir konuşmada (daha sonra?) Başka tavsiyeler verir, kabaca buradan bakın: https://youtu.be/xnqTKD8uD64?t=54m50s .

Onun tavsiyesi f, yapıyı bu havuz argümanlarından taşıyacağınızı varsayarak, yalnızca havuz argümanları alan bir fonksiyon için değer parametrelerini kullanmaya dayanır.

Bu genel yaklaşım, fsırasıyla lvalue ve rvalue argümanlarına göre uyarlanmış optimal bir uygulama ile karşılaştırıldığında, hem lvalue hem de rvalue argümanları için bir hareket yapıcısının ek yükünü ekler . Bunun neden böyle olduğunu görmek için , bir copy fparametresi aldığını varsayalım , burada Tbazı kopyalama ve taşıma yapıcı türü:

void f(T x) {
  T y{std::move(x)};
}

çağrı fBir değer bağımsız değişkeni ile çağrıldığında, bir kopya oluşturucunun kurulax ve bir hareket kurucusunun da kurmaya sonuçlanır y. Öte yandan, fbir rvalue argümanı ile çağrılmak bir hareket kurucusunun inşa edilmesine xve başka bir hareket kurucusunun inşaa çağrılmasına neden olury .

Genel olarak, flvalue argümanlarının optimum uygulaması aşağıdaki gibidir:

void f(const T& x) {
  T y{x};
}

Bu durumda, yalnızca bir kopya oluşturucu oluşturmaya çağrılır. y . fDeğerleme argümanlarının optimal uygulaması yine genel olarak şu şekildedir:

void f(T&& x) {
  T y{std::move(x)};
}

Bu durumda, yalnızca bir hamle yapıcısı y .

Bu nedenle mantıklı bir uzlaşma, bir değer parametresi almak ve optimal uygulama ile ilgili lvalue veya rvalue argümanları için ekstra bir hareket oluşturucu çağrısı yapmaktır, bu da Herb'in konuşmasında verilen tavsiyedir.

@ JDługosz'un yorumlarda belirttiği gibi, değere göre geçmek sadece lavabo argümanından bir nesne oluşturacak fonksiyonlar için anlamlıdır. fBağımsız değişkenini kopyalayan bir işleve sahip olduğunuzda, değere göre by-pass yaklaşımı, genel-by-const-referans yaklaşımından daha fazla ek yüke sahip olacaktır. fParametresinin bir kopyasını saklayan bir fonksiyonun değer bazında yaklaşımı şu şekle sahip olacaktır:

void f(T x) {
  T y{...};
  ...
  y = std::move(x);
}

Bu durumda, bir kopya yapısı ve bir değer bağımsız değişkeni için bir taşıma ataması ve bir değer bağımsız değişkeni için bir taşıma yapısı ve taşıma ataması vardır. Lvalue argümanı için en uygun durum:

void f(const T& x) {
  T y{...};
  ...
  y = x;
}

Bu, yalnızca kopya oluşturucudan artı değer-değeri yaklaşımı için gereken taşıma atamasından çok daha ucuz olan bir atamaya kadar kaynar. Bunun nedeni, atamanın mevcut ayrılan belleği yeniden kullanabilmesidir.y ve bu nedenle (de) ayırmayı önleyebilmesidir, oysa kopya oluşturucu genellikle belleği tahsis edecektir.

Bir rvalue argümanı için f, bir kopyayı muhafaza eden en uygun uygulama şu şekildedir:

void f(T&& x) {
  T y{...};
  ...
  y = std::move(x);
}

Yani, bu durumda sadece bir hareket ödevi. fBir const başvurusu alan sürümüne bir rvalue iletmek , bir taşıma ataması yerine yalnızca bir atamaya mal olur. Yani nispeten konuşursak,f bu durumda genel uygulama olarak bir const referansı alma tercih edilir.

Bu nedenle, genel olarak, en uygun uygulama için, konuşmada gösterildiği gibi aşırı yükleme veya bir tür mükemmel yönlendirme yapmanız gerekir. Dezavantajı, fargümanın değer kategorisinde aşırı yüklemeyi seçmeniz durumunda parametre sayısına bağlı olarak, gerekli aşırı yük sayısında bir kombinasyon patlamasıdır . Mükemmel yönlendirme, fsanallaştırmayı önleyen bir şablon işlevi haline gelen dezavantaja sahiptir ve % 100 doğru elde etmek istiyorsanız önemli ölçüde daha karmaşık bir kodla sonuçlanır (kanlı ayrıntılar için konuşmaya bakın).

Sorun "const" taneli olmayan bir niteleyici olmasıdır. Genellikle "const string ref" ile kastedilen "referans sayısını değiştirmeyin" değil, "bu dizeyi değiştirmeyin" dir. C ++ 'ta hangi üyelerin "const" olduğunu söylemenin hiçbir yolu yoktur . Hepsi ya öyle ya da hiçbiri değil.

Bu dil sorununu etrafında kesmek için, STL olabilir "C ()" seçeneğini örnekte bir hareket-semantik kopyasını izin zaten başvuru sayısı (değişebilir) bakımından "const" görmezden aldatılan ve. İyi tanımlandığı sürece, bu iyi olurdu.

STL olmadığından, const_casts <> referans sayacını uzatan bir dize sürümüne sahibim (geriye dönük olarak bir sınıf hiyerarşisinde değiştirilebilir bir şey yapmanın yolu yok) ve - lo ve işte - cmstring'in const başvuruları olarak serbestçe geçebileceğini, ve tüm gün boyunca sızıntı veya sorun yaşamadan derin işlevlerde kopyalarını alın.

C ++ burada "türetilmiş sınıf const granülerliği" sunmadığından, iyi bir şartname yazmak ve parlak yeni bir "const hareketli dize" (cmstring) nesnesi yapmak gördüğüm en iyi çözümdür.