std :: sprintf gibi dize biçimlendirme

Ben biçimine sahip std::stringolan sprintfve dosya akışı içine göndermek. Bunu nasıl yapabilirim?

Doğrudan yapamazsınız, çünkü temeldeki ara belleğe yazma erişiminiz yoktur (C ++ 11'e kadar; Dietrich Epp'in yorumuna bakın ). İlk önce bir c-string ile yapmanız ve ardından bir std :: string'e kopyalamanız gerekir:

  char buff[100];
  snprintf(buff, sizeof(buff), "%s", "Hello");
  std::string buffAsStdStr = buff;

Ama neden sadece bir string akışı kullanmıyorsunuz? Sadece bunu yapmak için değil, belirli nedenlerin olduğunu varsayıyorum:

  std::ostringstream stringStream;
  stringStream << "Hello";
  std::string copyOfStr = stringStream.str();

Modern C ++ bunu süper basitleştirir.

C ++ 20

C ++ 20std::format , tam olarak bunu yapmanızı sağlayan tanıtır . Bu benzer yedek alanlarını kullanan piton olanlar :

#include <iostream>
#include <format>

int main() {
    std::cout << std::format("Hello {}!\n", "world");
}

Tüm belgelere göz atın ! Büyük bir yaşam kalitesi iyileştirmesi.

C ++ 11

İle C ++ 11 s std::snprintf, bu zaten oldukça kolay ve güvenli bir görev haline geldi.

#include <memory>
#include <string>
#include <stdexcept>

template<typename ... Args>
std::string string_format( const std::string& format, Args ... args )
{
    size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1; // Extra space for '\0'
    if( size <= 0 ){ throw std::runtime_error( "Error during formatting." ); }
    std::unique_ptr<char[]> buf( new char[ size ] ); 
    snprintf( buf.get(), size, format.c_str(), args ... );
    return std::string( buf.get(), buf.get() + size - 1 ); // We don't want the '\0' inside
}

Yukarıdaki kod snippet'i CC0 1.0 altında lisanslanmıştır .

Satır satır açıklama:

Amaç: achar*tuşunu kullanarak yazınstd::snprintfve ardından a'ya dönüştürünstd::string.

İlk olarak, içinde özel bir koşul kullanarak char dizisinin istenen uzunluğunu belirleriz snprintf. Gönderen cppreference.com :

Geri dönüş değeri

[...] Sonuçta elde edilen dize buf_size sınırı nedeniyle kesilirse, işlev, sınır verilmemişse, yazılacak toplam karakter sayısını (sonlanan boş bayt dahil değil) döndürür.

Bu, istenen boyutun karakter sayısı artı bir olduğu anlamına gelir , böylece boş sonlandırıcı diğer tüm karakterlerin arkasına oturacak ve dize oluşturucu tarafından tekrar kesilebilecektir. Bu sorun yorumlarda @ alexk7 tarafından açıklanmıştır.

size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1;

snprintfbir hata oluşursa negatif bir sayı döndürür, bu nedenle biçimlendirmenin istendiği gibi çalışıp çalışmadığını kontrol ederiz. Bunu yapmamak, yorumlarda @ead'in belirttiği gibi sessiz hatalara veya büyük bir arabellek tahsisine yol açabilir.

if( size <= 0 ){ throw std::runtime_error( "Error during formatting." ); }

Ardından, yeni bir karakter dizisi atarız ve onu a'ya atarız std::unique_ptr. deleteBunu tekrar manuel olarak yapmak zorunda kalmayacağınız için genellikle tavsiye edilir .

Bunun, unique_ptryapıcı bir istisna atarsa ​​belleği ayıramayacağınız için kullanıcı tanımlı türlerle ayırmanın güvenli bir yolu olmadığını unutmayın !

std::unique_ptr<char[]> buf( new char[ size ] );

Bundan sonra, elbette sadece snprintfamaçlanan kullanımı için kullanabilir ve biçimlendirilmiş dizeyi char[].

snprintf( buf.get(), size, format.c_str(), args ... );

Son olarak, std::stringsonunda boş-sonlandırıcıyı atladığınızdan emin olarak yeni bir tane oluşturup iade ediyoruz .

return std::string( buf.get(), buf.get() + size - 1 );

Burada bir örnek görebilirsiniz .

std::stringArgüman listesinde de kullanmak istiyorsanız , bu özete bir göz atın .

Visual Studio kullanıcıları için ek bilgiler :

Açıklandığı gibi bu cevap Microsoft değiştirildi std::snprintfetmek _snprintf(evet, olmadan std::). MS ayrıca kullanımdan kaldırılmıştır ve _snprintf_sbunun yerine kullanılmasını önerir , ancak _snprintf_stamponun biçimlendirilmiş çıktıdan sıfır veya daha küçük olduğunu kabul etmez ve bu durumda çıktıların uzunluğunu hesaplamaz. Bu nedenle derleme sırasında kullanımdan kaldırma uyarılarından kurtulmak için dosyanın üst kısmına aşağıdakilerin kullanımını içeren aşağıdaki satırı ekleyebilirsiniz _snprintf:

#pragma warning(disable : 4996)

Son düşünceler

Bu soruya birçok cevap C ++ 11 zamanından önce yazılmıştır ve sabit tampon uzunlukları veya değişkenleri kullanılmıştır. C ++ 'ın eski sürümlerine bağlı kalmadıkça, bu çözümleri kullanmanızı tavsiye etmem. İdeal olarak, C ++ 20 yoluna gidin.

Bu yanıttaki C ++ 11 çözümü şablonlar kullandığından, çok kullanılırsa biraz kod üretebilir. Bununla birlikte, ikili dosyalar için çok sınırlı alana sahip bir ortam için geliştirmediğiniz sürece, bu bir sorun olmayacak ve hala hem açıklık hem de güvenlikteki diğer çözümlere göre büyük bir gelişme olacaktır.

Alan verimliliği çok önemliyse, değişkenler ve vsnprintf içeren bu iki çözüm yararlı olabilir. Sadece sorun isteyen sabit tampon uzunluklarına sahip herhangi bir çözüm KULLANMAYIN .

vsnprintf()Dahili olarak kullanılan C ++ 11 çözümü :

#include <stdarg.h>  // For va_start, etc.

std::string string_format(const std::string fmt, ...) {
    int size = ((int)fmt.size()) * 2 + 50;   // Use a rubric appropriate for your code
    std::string str;
    va_list ap;
    while (1) {     // Maximum two passes on a POSIX system...
        str.resize(size);
        va_start(ap, fmt);
        int n = vsnprintf((char *)str.data(), size, fmt.c_str(), ap);
        va_end(ap);
        if (n > -1 && n < size) {  // Everything worked
            str.resize(n);
            return str;
        }
        if (n > -1)  // Needed size returned
            size = n + 1;   // For null char
        else
            size *= 2;      // Guess at a larger size (OS specific)
    }
    return str;
}

Daha güvenli ve daha verimli (test ettim ve daha hızlı) bir yaklaşım:

#include <stdarg.h>  // For va_start, etc.
#include <memory>    // For std::unique_ptr

std::string string_format(const std::string fmt_str, ...) {
    int final_n, n = ((int)fmt_str.size()) * 2; /* Reserve two times as much as the length of the fmt_str */
    std::unique_ptr<char[]> formatted;
    va_list ap;
    while(1) {
        formatted.reset(new char[n]); /* Wrap the plain char array into the unique_ptr */
        strcpy(&formatted[0], fmt_str.c_str());
        va_start(ap, fmt_str);
        final_n = vsnprintf(&formatted[0], n, fmt_str.c_str(), ap);
        va_end(ap);
        if (final_n < 0 || final_n >= n)
            n += abs(final_n - n + 1);
        else
            break;
    }
    return std::string(formatted.get());
}

fmt_strGereklerine uymak için değeri tarafından geçirilir va_start.

NOT: "Daha güvenli" ve "daha hızlı" sürüm bazı sistemlerde çalışmaz. Bu nedenle, her ikisi de hala listelenmiştir. Ayrıca, "daha hızlı" tamamen önceden konumlandırma adımının doğru olmasına bağlıdır, aksi takdirde strcpyyavaşlar.

boost::format() istediğiniz işlevselliği sağlar:

Boost biçimi kitaplıkları özeti gelince:

Bir format nesnesi bir format-stringinden oluşturulur ve daha sonra% operatörüne tekrarlanan çağrılar yoluyla argümanlar verilir. Bu argümanların her biri daha sonra format-string'e göre bir dizeye birleştirilen dizelere dönüştürülür.

#include <boost/format.hpp>

cout << boost::format("writing %1%,  x=%2% : %3%-th try") % "toto" % 40.23 % 50; 
// prints "writing toto,  x=40.230 : 50-th try"

C ++ 20 , API açısından std::formatbenzer sprintfolan ancak tam olarak güvenli olan, kullanıcı tanımlı türlerle çalışan ve Python benzeri biçim dizesi sözdizimini kullanan içerir. std::stringBunu bir akışa nasıl biçimlendirip yazabileceğiniz aşağıda açıklanmıştır:

std::string s = "foo";
std::cout << std::format("Look, a string: {}", s);

veya

std::string s = "foo";
puts(std::format("Look, a string: {}", s).c_str());

Alternatif olarak, bir dizeyi biçimlendirmek ve tek seferde bir dosya akışına veya bir dosya akışına yazmak için {fmt} kitaplığını kullanabilirsiniz stdout:

fmt::print(f, "Look, a string: {}", s); // where f is a file stream

sprintfBuradaki diğer cevaplara veya çoğuna gelince , maalesef varargs kullanıyorlar ve formatsadece gerçek biçim dizeleriyle çalışan GCC özniteliği gibi bir şey kullanmazsanız doğal olarak güvenli değiller . Aşağıdaki örneklerde bu işlevlerin neden güvensiz olduğunu görebilirsiniz:

std::string format_str = "%s";
string_format(format_str, format_str[0]);

string_formatErik Aronesty'nin cevabından bir uygulama nerede . Bu kod derlenir, ancak çalıştırmaya çalıştığınızda büyük olasılıkla kilitlenir:

$ g++ -Wall -Wextra -pedantic test.cc 
$ ./a.out 
Segmentation fault: 11

Feragatname : {fmt} ve C ++ 20'nin yazarıyım std::format.

Yalnızca printf benzeri bir sözdizimi istiyorsanız (printf'i kendiniz çağırmadan), Boost Format'a bir göz atın .

Kendi arabelleğimi oluşturmak yerine dize döndürür vsnprintf kullanarak kendi yazdı.

#include <string>
#include <cstdarg>

//missing string printf
//this is safe and convenient but not exactly efficient
inline std::string format(const char* fmt, ...){
    int size = 512;
    char* buffer = 0;
    buffer = new char[size];
    va_list vl;
    va_start(vl, fmt);
    int nsize = vsnprintf(buffer, size, fmt, vl);
    if(size<=nsize){ //fail delete buffer and try again
        delete[] buffer;
        buffer = 0;
        buffer = new char[nsize+1]; //+1 for /0
        nsize = vsnprintf(buffer, size, fmt, vl);
    }
    std::string ret(buffer);
    va_end(vl);
    delete[] buffer;
    return ret;
}

Böylece kullanabilirsiniz

std::string mystr = format("%s %d %10.5f", "omg", 1, 10.5);

Biçimi için std::stringbir 'sprintf' şekilde, çağrı snprintf(bağımsız nullptrve 0gerekli tampon uzunluğunu elde etmek için). İşlevinizi aşağıdaki gibi C ++ 11 varyasyon şablonu kullanarak yazın:

#include <cstdio>
#include <string>
#include <cassert>

template< typename... Args >
std::string string_sprintf( const char* format, Args... args ) {
  int length = std::snprintf( nullptr, 0, format, args... );
  assert( length >= 0 );

  char* buf = new char[length + 1];
  std::snprintf( buf, length + 1, format, args... );

  std::string str( buf );
  delete[] buf;
  return str;
}

C ++ 11 desteğiyle derleyin, örneğin GCC'de: g++ -std=c++11

Kullanımı:

  std::cout << string_sprintf("%g, %g\n", 1.23, 0.001);

[değiştir: 20/05/25] daha da iyisi ...: Başlıkta
:

// `say` prints the values
// `says` returns a string instead of printing
// `sayss` appends the values to it's first argument instead of printing
// `sayerr` prints the values and returns `false` (useful for return statement fail-report)<br/>

void PRINTSTRING(const std::string &s); //cater for GUI, terminal, whatever..
template<typename...P> void say(P...p) { std::string r{}; std::stringstream ss(""); (ss<<...<<p); r=ss.str(); PRINTSTRING(r); }
template<typename...P> std::string says(P...p) { std::string r{}; std::stringstream ss(""); (ss<<...<<p); r=ss.str(); return r; }
template<typename...P> void sayss(std::string &s, P...p) { std::string r{}; std::stringstream ss(""); (ss<<...<<p); r=ss.str();  s+=r; } //APPENDS! to s!
template<typename...P> bool sayerr(P...p) { std::string r{}; std::stringstream ss("ERROR: "); (ss<<...<<p); r=ss.str(); PRINTSTRING(r); return false; }

PRINTSTRING(r)Taşımasının avantajlı GUI veya terminal veya kullanan herhangi bir özel çıkış ihtiyaçları için hitap etmektir #ifdef _some_flag_, varsayılan:

void PRINTSTRING(const std::string &s) { std::cout << s << std::flush; }

[değiştir '17 / 8/31] Değişken şablonlu 'vtspf (..)' sürümü ekleniyor:

template<typename T> const std::string type_to_string(const T &v)
{
    std::ostringstream ss;
    ss << v;
    return ss.str();
};

template<typename T> const T string_to_type(const std::string &str)
{
    std::istringstream ss(str);
    T ret;
    ss >> ret;
    return ret;
};

template<typename...P> void vtspf_priv(std::string &s) {}

template<typename H, typename...P> void vtspf_priv(std::string &s, H h, P...p)
{
    s+=type_to_string(h);
    vtspf_priv(s, p...);
}

template<typename...P> std::string temp_vtspf(P...p)
{
    std::string s("");
    vtspf_priv(s, p...);
    return s;
}

bu, bazen engellenen <<operatörlerin (bunun yerine) etkili bir şekilde virgülle sınırlandırılmış bir versiyonudur , şöyle kullanılır:

char chSpace=' ';
double pi=3.1415;
std::string sWorld="World", str_var;
str_var = vtspf("Hello", ',', chSpace, sWorld, ", pi=", pi);

Erik Aronesty'nin cevabındaki (yukarıda) tekniği kullanmak için uyarlanmıştır:

#include <string>
#include <cstdarg>
#include <cstdio>

//=============================================================================
void spf(std::string &s, const std::string fmt, ...)
{
    int n, size=100;
    bool b=false;
    va_list marker;

    while (!b)
    {
        s.resize(size);
        va_start(marker, fmt);
        n = vsnprintf((char*)s.c_str(), size, fmt.c_str(), marker);
        va_end(marker);
        if ((n>0) && ((b=(n<size))==true)) s.resize(n); else size*=2;
    }
}

//=============================================================================
void spfa(std::string &s, const std::string fmt, ...)
{
    std::string ss;
    int n, size=100;
    bool b=false;
    va_list marker;

    while (!b)
    {
        ss.resize(size);
        va_start(marker, fmt);
        n = vsnprintf((char*)ss.c_str(), size, fmt.c_str(), marker);
        va_end(marker);
        if ((n>0) && ((b=(n<size))==true)) ss.resize(n); else size*=2;
    }
    s += ss;
}

[önceki cevap]
Çok geç bir cevap, ama benim gibi 'sprintf' yolunu sevenler için: Ben yazdım ve aşağıdaki işlevleri kullanıyorum. Eğer isterseniz, sprintf'lere daha yakından uyacak şekilde% -options öğesini genişletebilirsiniz; oradaki olanlar benim ihtiyaçlarım için yeterli. Sprintf ile aynı stringf () ve stringfappend () yöntemlerini kullanırsınız. Sadece ... için parametrelerin POD türleri olması gerektiğini unutmayın.

//=============================================================================
void DoFormatting(std::string& sF, const char* sformat, va_list marker)
{
    char *s, ch=0;
    int n, i=0, m;
    long l;
    double d;
    std::string sf = sformat;
    std::stringstream ss;

    m = sf.length();
    while (i<m)
    {
        ch = sf.at(i);
        if (ch == '%')
        {
            i++;
            if (i<m)
            {
                ch = sf.at(i);
                switch(ch)
                {
                    case 's': { s = va_arg(marker, char*);  ss << s;         } break;
                    case 'c': { n = va_arg(marker, int);    ss << (char)n;   } break;
                    case 'd': { n = va_arg(marker, int);    ss << (int)n;    } break;
                    case 'l': { l = va_arg(marker, long);   ss << (long)l;   } break;
                    case 'f': { d = va_arg(marker, double); ss << (float)d;  } break;
                    case 'e': { d = va_arg(marker, double); ss << (double)d; } break;
                    case 'X':
                    case 'x':
                        {
                            if (++i<m)
                            {
                                ss << std::hex << std::setiosflags (std::ios_base::showbase);
                                if (ch == 'X') ss << std::setiosflags (std::ios_base::uppercase);
                                char ch2 = sf.at(i);
                                if (ch2 == 'c') { n = va_arg(marker, int);  ss << std::hex << (char)n; }
                                else if (ch2 == 'd') { n = va_arg(marker, int); ss << std::hex << (int)n; }
                                else if (ch2 == 'l') { l = va_arg(marker, long);    ss << std::hex << (long)l; }
                                else ss << '%' << ch << ch2;
                                ss << std::resetiosflags (std::ios_base::showbase | std::ios_base::uppercase) << std::dec;
                            }
                        } break;
                    case '%': { ss << '%'; } break;
                    default:
                    {
                        ss << "%" << ch;
                        //i = m; //get out of loop
                    }
                }
            }
        }
        else ss << ch;
        i++;
    }
    va_end(marker);
    sF = ss.str();
}

//=============================================================================
void stringf(string& stgt,const char *sformat, ... )
{
    va_list marker;
    va_start(marker, sformat);
    DoFormatting(stgt, sformat, marker);
}

//=============================================================================
void stringfappend(string& stgt,const char *sformat, ... )
{
    string sF = "";
    va_list marker;
    va_start(marker, sformat);
    DoFormatting(sF, sformat, marker);
    stgt += sF;
}

Google böyle yapar: StringPrintf(BSD Lisansı)
ve facebook bunu oldukça benzer bir şekilde yapar: StringPrintf(Apache Lisansı)
Her ikisi de uygun bir StringAppendFözellik sunar.

Bu çok popüler soru üzerine iki sentim.

Benzeri işlevlerin kılavuz sayfasınıprintf alıntılamak için :

Başarılı bir şekilde geri döndüğünde, bu işlevler yazdırılan karakter sayısını döndürür (çıktıyı dizelere sonlandırmak için kullanılan boş bayt hariç).

Snprintf () ve vsnprintf () işlevleri boyut baytlarından fazlasını yazmaz (sonlandırıcı boş bayt ('\ 0') dahil). Çıktı bu sınırdan dolayı kesilirse, dönüş değeri, yeterli alan varsa son dizeye yazılan karakter sayısıdır (sonlandırıcı boş bayt hariç). Böylece, boyut veya daha büyük bir dönüş değeri, çıktının kesildiği anlamına gelir.

Başka bir deyişle, aklı başında bir C ++ 11 uygulaması aşağıdaki gibi olmalıdır:

#include <string>
#include <cstdio>

template <typename... Ts>
std::string fmt (const std::string &fmt, Ts... vs)
{
    char b;
    size_t required = std::snprintf(&b, 0, fmt.c_str(), vs...) + 1;
        // See comments: the +1 is necessary, while the first parameter
        //               can also be set to nullptr

    char bytes[required];
    std::snprintf(bytes, required, fmt.c_str(), vs...);

    return std::string(bytes);
}

Oldukça iyi çalışıyor :)

Değişken şablonları yalnızca C ++ 11'de desteklenir. Piksel noktasından gelen cevap, eski programlama stillerini kullanarak benzer bir tekniği göstermektedir.

C ++ 'ın kutunun dışında böyle bir şey olmaması garip. Son zamanlarda to_string(), bence ileriye doğru büyük bir adım eklediler . Sonunda bir .formatoperatör ekleyip eklemeyeceklerini merak ediyorum std::string...

Düzenle

Alexk7'nin işaret ettiği gibi, bayt için yer +1olması gerektiğinden A'nın dönüş değerine std::snprintfihtiyaç vardır \0. Sezgisel olarak, eksik olan çoğu mimaride +1, requiredtamsayı a ile kısmen üzerine yazılacaktır 0. Bu, gerçek parametre olarak değerlendirildikten sonra gerçekleşecektir , bu nedenle etki görünmemelidir.requiredstd::snprintf

Ancak bu sorun, örneğin derleyici optimizasyonu ile değişebilir: derleyici requireddeğişken için bir kayıt kullanmaya karar verirse ne olur ? Bu, bazen güvenlik sorunlarına neden olan hatalardır.

template<typename... Args>
std::string string_format(const char* fmt, Args... args)
{
    size_t size = snprintf(nullptr, 0, fmt, args...);
    std::string buf;
    buf.reserve(size + 1);
    buf.resize(size);
    snprintf(&buf[0], size + 1, fmt, args...);
    return buf;
}

C99 snprintf ve C ++ 11 kullanma

Test Edilmiş, Üretim Kalitesi Cevabı

Bu cevap genel durumu standartlara uygun tekniklerle ele almaktadır. Aynı yaklaşım, sayfalarının alt kısmına yakın olan CppReference.com sitesinde de verilmiştir . Örneklerinden farklı olarak, bu kod sorunun gereksinimlerine uygundur ve robotik ve uydu uygulamalarında sahada test edilmiştir. Ayrıca yorumlarda da iyileşme oldu. Tasarım kalitesi aşağıda daha ayrıntılı tartışılmaktadır.

#include <string>
#include <cstdarg>
#include <vector>

// requires at least C++11
const std::string vformat(const char * const zcFormat, ...) {

    // initialize use of the variable argument array
    va_list vaArgs;
    va_start(vaArgs, zcFormat);

    // reliably acquire the size
    // from a copy of the variable argument array
    // and a functionally reliable call to mock the formatting
    va_list vaArgsCopy;
    va_copy(vaArgsCopy, vaArgs);
    const int iLen = std::vsnprintf(NULL, 0, zcFormat, vaArgsCopy);
    va_end(vaArgsCopy);

    // return a formatted string without risking memory mismanagement
    // and without assuming any compiler or platform specific behavior
    std::vector<char> zc(iLen + 1);
    std::vsnprintf(zc.data(), zc.size(), zcFormat, vaArgs);
    va_end(vaArgs);
    return std::string(zc.data(), iLen); }

#include <ctime>
#include <iostream>
#include <iomanip>

// demonstration of use
int main() {

    std::time_t t = std::time(nullptr);
    std::cerr
        << std::put_time(std::localtime(& t), "%D %T")
        << " [debug]: "
        << vformat("Int 1 is %d, Int 2 is %d, Int 3 is %d", 11, 22, 33)
        << std::endl;
    return 0; }

Öngörülebilir Doğrusal Verimlilik

İki geçiş soru özelliklerine göre güvenli, güvenilir ve öngörülebilir bir yeniden kullanılabilir fonksiyon için gerekliliklerdir. Yeniden kullanılabilir bir fonksiyonda değişken boyutlarının dağılımı hakkındaki varsayımlar kötü programlama stilidir ve kaçınılmalıdır. Bu durumda, değişkenlerin keyfi olarak büyük değişken uzunluk gösterimleri algoritma seçiminde anahtar bir faktördür.

Taşma üzerine yeniden denemek katlanarak verimsizdir, bu da C ++ 11 standart komitesi yazma tamponu boş olduğunda kuru bir çalışma sağlamak için yukarıdaki teklifi tartıştığında tartışılan başka bir nedendir.

Yukarıdaki üretime hazır uygulamada, ilk çalışma, tahsis boyutunu belirlemek için böyle bir kuru çalışmadır. Hiçbir ayırma gerçekleşmez. Printf direktiflerinin ayrıştırılması ve değişkenlerin okunması onlarca yıl boyunca son derece verimli hale getirilmiştir. Önemsiz vakalar için küçük bir verimsizliğin feda edilmesi gerekse bile yeniden kullanılabilir kod öngörülebilir olmalıdır.

Güvenlik ve Güvenilirlik

Andrew Koenig, bir Cambridge etkinliğindeki konferansından sonra küçük bir grubumuza, "Kullanıcı işlevleri, olağandışı işlevsellik başarısızlığından faydalanmamalı." Dedi. Her zamanki gibi, bilgeliği o zamandan beri kayıtta doğru olarak gösterildi. Düzeltilen ve kapatılan güvenlik hatası sorunları genellikle düzeltmeden önce kullanılan deliğin açıklamasındaki yeniden deneme saldırılarını gösterir.

Bu, sprintf Alternatifi, C9X Revizyon Teklifi , ISO IEC Belgesi WG14 N645 / X3J11 96-008'deki null tampon özelliği için resmi standartlar revizyon teklifinde belirtilmiştir . Dinamik bellek kullanılabilirliği kısıtlamaları dahilinde "% s" yazdırma yönergesi başına eklenen keyfi olarak uzun bir dize bir istisna değildir ve "Olağanüstü işlevsellik" üretmek için kullanılmamalıdır.

Teklifi, bu cevabın ilk paragrafında bağlantısı verilen C ++ Reference.org sayfasının alt kısmında verilen örnek kodu düşünün.

Ayrıca, başarısızlık vakalarının testi nadiren başarılı vakalar kadar sağlamdır.

taşınabilirlik

Tüm büyük işletim sistemi satıcıları, c ++ 11 standartlarının bir parçası olarak std :: vsnprintf'i tam olarak destekleyen derleyiciler sağlar. Artık dağıtımları sürdürmeyen satıcıların ürünlerini çalıştıran ana makineler, birçok nedenden dolayı g ++ veya clang ++ ile donatılmalıdır.

Yığın Kullanımı

Std :: vsnprintf'e yapılan ilk çağrıda yığın kullanımı, 2. çağrıdan daha az veya ona eşit olacak ve 2. çağrı başlamadan önce serbest bırakılacaktır. İlk çağrı yığın kullanılabilirliğini aşarsa, std :: fprintf de başarısız olur.

C ++ 20 std::format

Geldi! Bu özellik http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0645r9.html adresinde açıklanmıştır ve Python benzeri bir .format()sözdizimi kullanır .

Kullanımın şöyle olacağını düşünüyorum:

#include <format>
#include <string>

int main() {
    std::string message = std::format("The answer is {}.", 42);
}

Destek GCC'ye geldiğinde bir deneyeceğim, GCC 9.1.0 g++-9 -std=c++2ahala desteklemiyor.

API yeni bir std::formatbaşlık ekleyecektir :

Önerilen biçimlendirme API'sı yeni başlıkta tanımlanmıştır <format>ve mevcut kod üzerinde hiçbir etkisi olmamalıdır.

Mevcut fmtkütüphane çoklu doldurmaya ihtiyacınız varsa uygulamayı uyguladığını iddia ediyor: https://github.com/fmtlib/fmt

C ++ 20'nin uygulanması std::format.

ve daha önce şu adreste bahsedilmişti: std :: sprintf gibi dize biçimlendirme

Erik Aronesty'nin verdiği cevaba dayanarak:

std::string string_format(const std::string &fmt, ...) {
    std::vector<char> str(100,'\0');
    va_list ap;
    while (1) {
        va_start(ap, fmt);
        auto n = vsnprintf(str.data(), str.size(), fmt.c_str(), ap);
        va_end(ap);
        if ((n > -1) && (size_t(n) < str.size())) {
            return str.data();
        }
        if (n > -1)
            str.resize( n + 1 );
        else
            str.resize( str.size() * 2);
    }
    return str.data();
}

Bu const, sonucun .c_str()orijinal cevapta olandan uzaklaşma ihtiyacını ortadan kaldırır .

inline void format(string& a_string, const char* fmt, ...)
{
    va_list vl;
    va_start(vl, fmt);
    int size = _vscprintf( fmt, vl );
    a_string.resize( ++size );
    vsnprintf_s((char*)a_string.data(), size, _TRUNCATE, fmt, vl);
    va_end(vl);
}

string ihtiyacınız olan şeye sahip değil, ancak std :: stringstream. Dizeyi oluşturmak için bir dize akışı kullanın ve sonra dizeyi çıkarın. İşte yapabileceğiniz şeylerin kapsamlı bir listesi. Örneğin:

cout.setprecision(10); //stringstream is a stream like cout

bir çift veya float yazdırırken size 10 ondalık hassasiyet yeri verecektir.

Bunu deneyebilirsiniz:

string str;
str.resize( _MAX_PATH );

sprintf( &str[0], "%s %s", "hello", "world" );
// optionals
// sprintf_s( &str[0], str.length(), "%s %s", "hello", "world" ); // Microsoft
// #include <stdio.h>
// snprintf( &str[0], str.length(), "%s %s", "hello", "world" ); // c++11

str.resize( strlen( str.data() ) + 1 );

Asprintf (3) olan bir sistemdeyseniz , kolayca sarabilirsiniz:

#include <iostream>
#include <cstdarg>
#include <cstdio>

std::string format(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));

std::string format(const char *fmt, ...)
{
    std::string result;

    va_list ap;
    va_start(ap, fmt);

    char *tmp = 0;
    int res = vasprintf(&tmp, fmt, ap);
    va_end(ap);

    if (res != -1) {
        result = tmp;
        free(tmp);
    } else {
        // The vasprintf call failed, either do nothing and
        // fall through (will return empty string) or
        // throw an exception, if your code uses those
    }

    return result;
}

int main(int argc, char *argv[]) {
    std::string username = "you";
    std::cout << format("Hello %s! %d", username.c_str(), 123) << std::endl;
    return 0;
}

Bu benim programda bunu yapmak için kullandığım kod ... Bu fantezi bir şey, ama hile yapar ... Not, boyutunuzu uygulanabilir olarak ayarlamak zorunda kalacak. Benim için MAX_BUFFER 1024.

std::string Format ( const char *fmt, ... )
{
    char textString[MAX_BUFFER*5] = {'\0'};

    // -- Empty the buffer properly to ensure no leaks.
    memset(textString, '\0', sizeof(textString));

    va_list args;
    va_start ( args, fmt );
    vsnprintf ( textString, MAX_BUFFER*5, fmt, args );
    va_end ( args );
    std::string retStr = textString;
    return retStr;
}

Bu fikri Dacav ve pixelpoint'in cevabından aldı . Biraz oynadım ve anladım:

#include <cstdarg>
#include <cstdio>
#include <string>

std::string format(const char* fmt, ...)
{
    va_list vl;

    va_start(vl, fmt);
    int size = vsnprintf(0, 0, fmt, vl) + sizeof('\0');
    va_end(vl);

    char buffer[size];

    va_start(vl, fmt);
    size = vsnprintf(buffer, size, fmt, vl);
    va_end(vl);

    return std::string(buffer, size);
}

İle aklı başında programlama pratikte ancak ben hala hala yeterince basittir ve C ++ 11 gerektirmediğine daha güvenli alternatiflere açığım, kod yeterli olması gerektiğine inanıyoruz.

Ve burada vsnprintf(), ilk arabellek zaten yeterli olduğunda ikinci aramayı önlemek için bir ilk arabellek kullanan başka bir sürüm .

std::string format(const char* fmt, ...)
{

    va_list vl;
    int size;

    enum { INITIAL_BUFFER_SIZE = 512 };

    {
        char buffer[INITIAL_BUFFER_SIZE];

        va_start(vl, fmt);
        size = vsnprintf(buffer, INITIAL_BUFFER_SIZE, fmt, vl);
        va_end(vl);

        if (size < INITIAL_BUFFER_SIZE)
            return std::string(buffer, size);
    }

    size += sizeof('\0');

    char buffer[size];

    va_start(vl, fmt);
    size = vsnprintf(buffer, size, fmt, vl);
    va_end(vl);

    return std::string(buffer, size);
}

(Bu sürümün sadece Piti Ongmongkolkul'un cevabına benzediği , sadece kullanmadığı newve delete[]oluştururken bir boyut belirttiği ortaya çıkıyor std::string.

Burada kullanılmaması newve delete[]yığının yığın üzerinde kullanımını ima etmesi fikri , tahsis ve yeniden yerleştirme işlevlerini çağırması gerekmediği için, ancak düzgün kullanılmazsa, bazı taşmalarda (belki de eski veya belki sadece savunmasız) sistemler. Bu bir endişe ise, newvedelete[] yerine . Buradaki tek endişenin vsnprintf()zaten limitlerle çağrıldığı gibi tahsislerle ilgili olduğunu unutmayın , bu nedenle ikinci tamponda tahsis edilen boyuta dayalı bir limit belirtmek de bunları önleyecektir.)

Genellikle bunu kullanıyorum:

std::string myformat(const char *const fmt, ...)
{
        char *buffer = NULL;
        va_list ap;

        va_start(ap, fmt);
        (void)vasprintf(&buffer, fmt, ap);
        va_end(ap);

        std::string result = buffer;
        free(buffer);

        return result;
}

Dezavantajı: tüm sistemler vazpini desteklemez

@ İFreilicht cevabının biraz değiştirilmiş versiyonunun altında, C ++ 14 ( make_uniqueham beyan yerine fonksiyon kullanımı ) ve std::stringargümanlar için destek eklendi (Kenny Kerr makalesine dayanarak )

#include <iostream>
#include <memory>
#include <string>
#include <cstdio>

template <typename T>
T process_arg(T value) noexcept
{
    return value;
}

template <typename T>
T const * process_arg(std::basic_string<T> const & value) noexcept
{
    return value.c_str();
}

template<typename ... Args>
std::string string_format(const std::string& format, Args const & ... args)
{
    const auto fmt = format.c_str();
    const size_t size = std::snprintf(nullptr, 0, fmt, process_arg(args) ...) + 1;
    auto buf = std::make_unique<char[]>(size);
    std::snprintf(buf.get(), size, fmt, process_arg(args) ...);
    auto res = std::string(buf.get(), buf.get() + size - 1);
    return res;
}

int main()
{
    int i = 3;
    float f = 5.f;
    char* s0 = "hello";
    std::string s1 = "world";
    std::cout << string_format("i=%d, f=%f, s=%s %s", i, f, s0, s1) << "\n";
}

Çıktı:

i = 3, f = 5.000000, s = hello world

İsterseniz bu cevabı orijinaliyle birleştirmekten çekinmeyin.

Poco Foundation kütüphanesi, hem format dizesinde hem de değerlerde std :: string'i destekleyen çok uygun bir format fonksiyonuna sahiptir:

• Doküman: http://pocoproject.org/docs/Poco.html#7308
• Kaynak: https://github.com/pocoproject/poco/blob/develop/Foundation/src/Format.cpp

Cio çıktısını iomanip başlık dosyasını kullanarak cout'ta biçimlendirebilirsiniz. Setprecision, setfill vb. Yardımcı işlevlerden herhangi birini kullanmadan önce iomanip başlık dosyasını eklediğinizden emin olun.

Burada, geçmişte "birikmiş" olduğum vektörde ortalama bekleme süresini yazdırmak için kullandığım bir kod snippet'i var.

#include<iomanip>
#include<iostream>
#include<vector>
#include<numeric>

...

cout<< "Average waiting times for tasks is " << setprecision(4) << accumulate(all(waitingTimes), 0)/double(waitingTimes.size()) ;
cout << " and " << Q.size() << " tasks remaining" << endl;

İşte C ++ akışlarını nasıl biçimlendirebileceğimize dair kısa bir açıklama. http://www.cprogramming.com/tutorial/iomanip.html

Arabellek dizgiyi yazdıracak kadar büyük değilse, sorunlar olabilir. Orada biçimlendirilmiş bir ileti yazdırmadan önce biçimlendirilmiş dizenin uzunluğunu belirlemelisiniz. Buna kendi yardımcısını yapıyorum (Windows ve Linux GCC'de test edildi ) ve kullanmayı deneyebilirsiniz.

String.cpp: http://pastebin.com/DnfvzyKP
String.h: http://pastebin.com/7U6iCUMa

String.cpp:

#include <cstdio>
#include <cstdarg>
#include <cstring>
#include <string>

using ::std::string;

#pragma warning(disable : 4996)

#ifndef va_copy
#ifdef _MSC_VER
#define va_copy(dst, src) dst=src
#elif !(__cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__))
#define va_copy(dst, src) memcpy((void*)dst, (void*)src, sizeof(*src))
#endif
#endif

///
/// \breif Format message
/// \param dst String to store formatted message
/// \param format Format of message
/// \param ap Variable argument list
///
void toString(string &dst, const char *format, va_list ap) throw() {
  int length;
  va_list apStrLen;
  va_copy(apStrLen, ap);
  length = vsnprintf(NULL, 0, format, apStrLen);
  va_end(apStrLen);
  if (length > 0) {
    dst.resize(length);
    vsnprintf((char *)dst.data(), dst.size() + 1, format, ap);
  } else {
    dst = "Format error! format: ";
    dst.append(format);
  }
}

///
/// \breif Format message
/// \param dst String to store formatted message
/// \param format Format of message
/// \param ... Variable argument list
///
void toString(string &dst, const char *format, ...) throw() {
  va_list ap;
  va_start(ap, format);
  toString(dst, format, ap);
  va_end(ap);
}

///
/// \breif Format message
/// \param format Format of message
/// \param ... Variable argument list
///
string toString(const char *format, ...) throw() {
  string dst;
  va_list ap;
  va_start(ap, format);
  toString(dst, format, ap);
  va_end(ap);
  return dst;
}

///
/// \breif Format message
/// \param format Format of message
/// \param ap Variable argument list
///
string toString(const char *format, va_list ap) throw() {
  string dst;
  toString(dst, format, ap);
  return dst;
}


int main() {
  int a = 32;
  const char * str = "This works!";

  string test(toString("\nSome testing: a = %d, %s\n", a, str));
  printf(test.c_str());

  a = 0x7fffffff;
  test = toString("\nMore testing: a = %d, %s\n", a, "This works too..");
  printf(test.c_str());

  a = 0x80000000;
  toString(test, "\nMore testing: a = %d, %s\n", a, "This way is cheaper");
  printf(test.c_str());

  return 0;
}

string.h:

#pragma once
#include <cstdarg>
#include <string>

using ::std::string;

///
/// \breif Format message
/// \param dst String to store formatted message
/// \param format Format of message
/// \param ap Variable argument list
///
void toString(string &dst, const char *format, va_list ap) throw();
///
/// \breif Format message
/// \param dst String to store formatted message
/// \param format Format of message
/// \param ... Variable argument list
///
void toString(string &dst, const char *format, ...) throw();
///
/// \breif Format message
/// \param format Format of message
/// \param ... Variable argument list
///
string toString(const char *format, ...) throw();

///
/// \breif Format message
/// \param format Format of message
/// \param ap Variable argument list
///
string toString(const char *format, va_list ap) throw();

_return.desc = (boost::format("fail to detect. cv_result = %d") % st_result).str();

Çok çok basit bir çözüm.

std::string strBuf;
strBuf.resize(256);
int iCharsPrinted = sprintf_s((char *)strPath.c_str(), strPath.size(), ...);
strBuf.resize(iCharsPrinted);

Bunun birçok kez cevaplandığını anlıyorum, ama bu daha özlü:

std::string format(const std::string fmt_str, ...)
{
    va_list ap;
    char *fp = NULL;
    va_start(ap, fmt_str);
    vasprintf(&fp, fmt_str.c_str(), ap);
    va_end(ap);
    std::unique_ptr<char[]> formatted(fp);
    return std::string(formatted.get());
}

misal:

#include <iostream>
#include <random>

int main()
{
    std::random_device r;
    std::cout << format("Hello %d!\n", r());
}

Ayrıca bkz http://rextester.com/NJB14150

GÜNCELLEME 1 : eklenen fmt::formattestler

Burada tanıtılan yöntemler hakkında kendi araştırmamı yaptım ve burada belirtilenlere göre taban tabana zıt sonuçlar elde ediyorum.

4 yöntem üzerinde 4 işlev kullandım:

• değişken işlev + vsnprintf+std::unique_ptr
• değişken işlev + vsnprintf+std::string
• değişken şablon işlevi + std::ostringstream+ std::tuple+utility::for_each
• fmt::formatfmtkütüphaneden fonksiyon

Test arka ucu için googletestkullanılmıştır.

#include <string>
#include <cstdarg>
#include <cstdlib>
#include <memory>
#include <algorithm>

#include <fmt/format.h>

inline std::string string_format(size_t string_reserve, const std::string fmt_str, ...)
{
    size_t str_len = (std::max)(fmt_str.size(), string_reserve);

    // plain buffer is a bit faster here than std::string::reserve
    std::unique_ptr<char[]> formatted;

    va_list ap;
    va_start(ap, fmt_str);

    while (true) {
        formatted.reset(new char[str_len]);

        const int final_n = vsnprintf(&formatted[0], str_len, fmt_str.c_str(), ap);

        if (final_n < 0 || final_n >= int(str_len))
            str_len += (std::abs)(final_n - int(str_len) + 1);
        else
            break;
    }

    va_end(ap);

    return std::string(formatted.get());
}

inline std::string string_format2(size_t string_reserve, const std::string fmt_str, ...)
{
    size_t str_len = (std::max)(fmt_str.size(), string_reserve);
    std::string str;

    va_list ap;
    va_start(ap, fmt_str);

    while (true) {
        str.resize(str_len);

        const int final_n = vsnprintf(const_cast<char *>(str.data()), str_len, fmt_str.c_str(), ap);

        if (final_n < 0 || final_n >= int(str_len))
            str_len += (std::abs)(final_n - int(str_len) + 1);
        else {
            str.resize(final_n); // do not forget to shrink the size!
            break;
        }
    }

    va_end(ap);

    return str;
}

template <typename... Args>
inline std::string string_format3(size_t string_reserve, Args... args)
{
    std::ostringstream ss;
    if (string_reserve) {
        ss.rdbuf()->str().reserve(string_reserve);
    }
    std::tuple<Args...> t{ args... };
    utility::for_each(t, [&ss](auto & v)
    {
        ss << v;
    });
    return ss.str();
}

for_eachUygulama buradan alınır: iterate başlığın üzerinde

#include <type_traits>
#include <tuple>

namespace utility {

    template <std::size_t I = 0, typename FuncT, typename... Tp>
    inline typename std::enable_if<I == sizeof...(Tp), void>::type
        for_each(std::tuple<Tp...> &, const FuncT &)
    {
    }

    template<std::size_t I = 0, typename FuncT, typename... Tp>
    inline typename std::enable_if<I < sizeof...(Tp), void>::type
        for_each(std::tuple<Tp...> & t, const FuncT & f)
    {
        f(std::get<I>(t));
        for_each<I + 1, FuncT, Tp...>(t, f);
    }

}

Testler:

TEST(ExternalFuncs, test_string_format_on_unique_ptr_0)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format(0, "%s+%u\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_unique_ptr_256)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format(256, "%s+%u\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_std_string_0)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format2(0, "%s+%u\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_std_string_256)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format2(256, "%s+%u\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_string_stream_on_variadic_tuple_0)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format3(0, "test test test", "+", 12345, "\n");
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_string_stream_on_variadic_tuple_256)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = string_format3(256, "test test test", "+", 12345, "\n");
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_string_stream_inline_0)
{
    for (size_t i = 0; i < 1000000; i++) {
        std::ostringstream ss;
        ss << "test test test" << "+" << 12345 << "\n";
        const std::string v = ss.str();
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_string_format_on_string_stream_inline_256)
{
    for (size_t i = 0; i < 1000000; i++) {
        std::ostringstream ss;
        ss.rdbuf()->str().reserve(256);
        ss << "test test test" << "+" << 12345 << "\n";
        const std::string v = ss.str();
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_fmt_format_positional)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = fmt::format("{0:s}+{1:d}\n", "test test test", 12345);
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

TEST(ExternalFuncs, test_fmt_format_named)
{
    for (size_t i = 0; i < 1000000; i++) {
        const std::string v = fmt::format("{first:s}+{second:d}\n", fmt::arg("first", "test test test"), fmt::arg("second", 12345));
        UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(v);
    }
}

UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR.

unorted.hpp :

#define UTILITY_SUPPRESS_OPTIMIZATION_ON_VAR(var)   ::utility::unused_param(&var)

namespace utility {

    extern const volatile void * volatile g_unused_param_storage_ptr;

    extern void
#ifdef __GNUC__
    __attribute__((optimize("O0")))
#endif
        unused_param(const volatile void * p);

}

unused.cpp :

namespace utility {

    const volatile void * volatile g_unused_param_storage_ptr = nullptr;

    void
#ifdef __GNUC__
    __attribute__((optimize("O0")))
#endif
        unused_param(const volatile void * p)
    {
        g_unused_param_storage_ptr = p;
    }

}

SONUÇLAR :

[ RUN      ] ExternalFuncs.test_string_format_on_unique_ptr_0
[       OK ] ExternalFuncs.test_string_format_on_unique_ptr_0 (556 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_unique_ptr_256
[       OK ] ExternalFuncs.test_string_format_on_unique_ptr_256 (331 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_std_string_0
[       OK ] ExternalFuncs.test_string_format_on_std_string_0 (457 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_std_string_256
[       OK ] ExternalFuncs.test_string_format_on_std_string_256 (279 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_string_stream_on_variadic_tuple_0
[       OK ] ExternalFuncs.test_string_format_on_string_stream_on_variadic_tuple_0 (1214 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_string_stream_on_variadic_tuple_256
[       OK ] ExternalFuncs.test_string_format_on_string_stream_on_variadic_tuple_256 (1325 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_string_stream_inline_0
[       OK ] ExternalFuncs.test_string_format_on_string_stream_inline_0 (1208 ms)
[ RUN      ] ExternalFuncs.test_string_format_on_string_stream_inline_256
[       OK ] ExternalFuncs.test_string_format_on_string_stream_inline_256 (1302 ms)
[ RUN      ] ExternalFuncs.test_fmt_format_positional
[       OK ] ExternalFuncs.test_fmt_format_positional (288 ms)
[ RUN      ] ExternalFuncs.test_fmt_format_named
[       OK ] ExternalFuncs.test_fmt_format_named (392 ms)

Gördüğünüz gibi vsnprintf+ std::stringile uygulama eşittir fmt::format, ancak vsnprintf+ ile std::unique_ptrolandan daha hızlıdır std::ostringstream.

Testler derlendi Visual Studio 2015 Update 3ve adresinde gerçekleştirildi Windows 7 x64 / Intel Core i7-4820K CPU @ 3.70GHz / 16GB.