Std :: string parametrelerine 0'dan en iyi nasıl korunulur?

Sadece rahatsız edici bir şey fark ettim. std::stringParamater olarak kabul eden bir yöntem her yazışımda, kendimi tanımlanmamış davranışa açtım.

Örneğin, bu ...

void myMethod(const std::string& s) { 
    /* Do something with s. */
}

... böyle denebilir ...

char* s = 0;
myMethod(s);

... ve bunu önlemek için yapabileceğim hiçbir şey yok (farkında olduğum).

Benim sorum şu: Birisi kendini bundan nasıl koruyor?

Akla gelen tek yaklaşım, her zaman std::stringbir parametre olarak kabul eden herhangi bir yöntemin iki versiyonunu yazmaktır , örneğin:

void myMethod(const std::string& s) {
    /* Do something. */
}

void myMethod(char* s) {
    if (s == 0) {
        throw std::exception("Null passed.");
    } else {
        myMethod(string(s));
    }
}

Bu yaygın ve / veya kabul edilebilir bir çözüm müdür?

DÜZENLEME: Bazıları parametre const std::string& syerine kabul etmem gerektiğini belirtti std::string s. Katılıyorum. Gönderiyi değiştirdim. Bunun cevabı değiştirdiğini sanmıyorum.

Kendinizi korumanız gerektiğini düşünmüyorum. Arayan tarafında tanımsız davranış. Sen değilsin, arayan arayan std::string::string(nullptr), izin verilmeyen şey bu. Derleyici derlenmesine izin verir, ancak diğer tanımlanmamış davranışların da derlenmesine izin verir.

Aynı şekilde "boş başvuru" elde edilir:

int* p = nullptr;
f(*p);
void f(int& x) { x = 0; /* bang! */ }

Boş göstericiyi kaydeden kişi UB yapıyor ve bundan sorumlu.

Üstelik sen olamaz iyileştirici tanımsız davranış hiç olmamış farz tam sağ olduğu için eğer tanımsız davranış, böylece kontrolleri oldu sonra kendinizi korumak c_str()boş dışarı optimize edilebilir olduğunu.

Aşağıdaki kod, açık geçişi için derleme hatası 0ve değeri olan bir çalışma zamanı hatası char*verir0 .

Birinin normalde bunu yapması gerektiğini ima etmiyorum, ancak şüphesiz arayan hatasından korumanın haklı olduğu durumlar olabilir.

struct Test
{
    template<class T> void myMethod(T s);
};

template<> inline void Test::myMethod(const std::string& s)
{
    std::cout << "Cool " << std::endl;
}

template<> inline void Test::myMethod(const char* s)
{
    if (s != 0)
        myMethod(std::string(s));
    else
    {
        throw "Bad bad bad";
    }
}

template<class T> inline void Test::myMethod(T  s)
{
    myMethod(std::string(s));
    const bool ok = !std::is_same<T,int>::value;
    static_assert(ok, "oops");
}

int main()
{
    Test t;
    std::string s ("a");
    t.myMethod("b");
    const char* c = "c";
    t.myMethod(c);
    const char* d = 0;
    t.myMethod(d); // run time exception
    t.myMethod(0); // Compile failure
}

Birkaç yıl önce bu problemle de karşılaştım ve gerçekten çok korkutucu bir şey buldum. Bir nullptrdeğeri geçerek veya yanlışlıkla 0 değerine sahip bir int geçirerek olabilir. Gerçekten saçma:

std::string s(1); // compile error
std::string s(0); // runtime error

Ancak, sonunda bu sadece birkaç kez beni rahatsız etti. Ve her zaman kodumu test ederken hemen bir çökmeye neden oldu. Bu nedenle, düzeltmek için gece boyunca oturum gerekmez.

Bence fonksiyonu aşırı yüklemek const char*iyi bir fikir.

void foo(std::string s)
{
    // work
}

void foo(const char* s) // use const char* rather than char* (binds to string literals)
{
    assert(s); // I would use assert or std::abort in case of nullptr . 
    foo(std::string(s));
}

Keşke daha güzel bir çözüm mümkün olsaydı. Ancak, yoktur.

Yönteminizin imzasını şu şekilde değiştirmeye ne dersiniz?

void myMethod(std::string& s) // maybe throw const in there too.

Bu şekilde arayanın, onu çağırmadan önce bir dize oluşturması gerekir ve endişelendiğiniz özensizlik, yönteminize ulaşmadan önce sorunlara neden olur ve diğerlerinin işaret ettiklerini, sizin değil, arayanın hatası olduğunu açıklığa kavuşturur.

Aşırı yükte bir intparametreyi nasıl alırsınız ?

public:
    void myMethod(const std::string& s)
    { 
        /* Do something with s. */
    }    

private:
    void myMethod(int);

Aşırı yüklemeyi tanımlamanız bile gerekmez. Aramaya çalışmak myMethod(0)bir bağlayıcı hatası tetikleyecektir.

A ile çağırmayı denerseniz, ilk kod bloğundaki yönteminiz asla çağrılmaz (char *)0. C ++ basitçe bir dize oluşturmaya çalışır ve sizin için istisna atar. Onu denedin mi?

#include <cstdlib>
#include <iostream>

void myMethod(std::string s) {
    std::cout << "s=" << s << "\n";
}

int main(int argc,char **argv) {
    char *s = 0;
    myMethod(s);
    return(0);
}


$ g++ -g -o x x.cpp 
$ lldb x 
(lldb) run
Process 2137 launched: '/Users/simsong/x' (x86_64)
Process 2137 stopped
* thread #1: tid = 0x49b8, 0x00007fff99bf9812 libsystem_c.dylib`strlen + 18, queue = 'com.apple.main-thread, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
    frame #0: 0x00007fff99bf9812 libsystem_c.dylib`strlen + 18
libsystem_c.dylib`strlen + 18:
-> 0x7fff99bf9812:  pcmpeqb (%rdi), %xmm0
   0x7fff99bf9816:  pmovmskb %xmm0, %esi
   0x7fff99bf981a:  andq   $15, %rcx
   0x7fff99bf981e:  orq    $-1, %rax
(lldb) bt
* thread #1: tid = 0x49b8, 0x00007fff99bf9812 libsystem_c.dylib`strlen + 18, queue = 'com.apple.main-thread, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
    frame #0: 0x00007fff99bf9812 libsystem_c.dylib`strlen + 18
    frame #1: 0x000000010000077a x`main [inlined] std::__1::char_traits<char>::length(__s=0x0000000000000000) + 122 at string:644
    frame #2: 0x000000010000075d x`main [inlined] std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::basic_string(this=0x00007fff5fbff548, __s=0x0000000000000000) + 8 at string:1856
    frame #3: 0x0000000100000755 x`main [inlined] std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::basic_string(this=0x00007fff5fbff548, __s=0x0000000000000000) at string:1857
    frame #4: 0x0000000100000755 x`main(argc=1, argv=0x00007fff5fbff5e0) + 85 at x.cpp:10
    frame #5: 0x00007fff92ea25fd libdyld.dylib`start + 1
(lldb) 

Görmek? Endişelenecek bir şeyin yok.

Şimdi bunu biraz daha zarif bir şekilde yakalamak istiyorsanız, sadece kullanmamalısınız char *, o zaman sorun ortaya çıkmaz.

Char * 'ın potansiyel olarak boş göstergeler (örneğin, harici C API'lerinden döndürme) olması konusunda endişeleriniz varsa, sorunun işlevi std :: string one yerine const char * sürümünü kullanmaktır. yani

void myMethod(const char* c) { 
    std::string s(c ? c : "");
    /* Do something with s. */
}

Tabii bunların kullanılmasına izin vermek istiyorsanız std :: string versiyonuna da ihtiyacınız olacak.

Genel olarak, harici API'lere ve mareşal argümanlarına yapılan çağrıları geçerli değerlere ayırmak en iyisidir.