วิธีการป้องกันที่ดีที่สุดจาก 0 ผ่านไปยัง std :: พารามิเตอร์สตริง?

ฉันเพิ่งรู้ว่ามีอะไรรบกวน ทุกครั้งที่ฉันได้เขียนวิธีการที่ยอมรับstd::stringว่าเป็นพารามิเตอร์ฉันได้เปิดตัวเองเพื่อพฤติกรรมที่ไม่ได้กำหนด

ตัวอย่างเช่นสิ่งนี้ ...

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

... สามารถเรียกได้ว่าเป็นแบบนี้ ...

char* s = 0;
myMethod(s);

... และไม่มีอะไรที่ฉันสามารถทำได้เพื่อป้องกันมัน (ที่ฉันรู้)

ดังนั้นคำถามของฉันคือ: มีคนป้องกันตัวเองจากสิ่งนี้ได้อย่างไร

วิธีการเดียวที่อยู่ในใจคือการเขียนวิธีการสองแบบที่ยอมรับstd::stringเป็นพารามิเตอร์ดังนี้:

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

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

นี่เป็นวิธีแก้ปัญหาทั่วไปและ / หรือที่ยอมรับได้หรือไม่?

แก้ไข: บางคนชี้ให้เห็นว่าฉันควรยอมรับconst std::string& sแทนที่จะstd::string sเป็นพารามิเตอร์ ฉันเห็นด้วย. ฉันแก้ไขโพสต์ ฉันไม่คิดว่าจะเปลี่ยนคำตอบ

ฉันไม่คิดว่าคุณควรปกป้องตัวเอง มันเป็นพฤติกรรมที่ไม่ได้กำหนดที่ด้านข้างของผู้โทร ไม่ใช่คุณมันเป็นผู้โทรที่โทรstd::string::string(nullptr)มาซึ่งเป็นสิ่งที่ไม่ได้รับอนุญาต คอมไพเลอร์ช่วยให้สามารถคอมไพล์ได้ แต่ก็อนุญาตให้คอมไพล์พฤติกรรมที่ไม่ได้กำหนดอื่น ๆ ได้เช่นกัน

วิธีเดียวกันจะได้รับ "การอ้างอิงที่เป็นโมฆะ":

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

ผู้ที่อ้างถึงตัวชี้โมฆะกำลังสร้าง UB และรับผิดชอบมัน

ยิ่งกว่านั้นคุณไม่สามารถป้องกันตัวเองได้หลังจากพฤติกรรมที่ไม่ได้กำหนดเกิดขึ้นเนื่องจากเครื่องมือเพิ่มประสิทธิภาพมีสิทธิ์เต็มที่ที่จะคิดว่าพฤติกรรมที่ไม่ได้กำหนดไม่เคยเกิดขึ้นดังนั้นการตรวจสอบว่าc_str()มีค่าเป็นโมฆะหรือไม่

โค้ดข้างล่างนี้จะช่วยให้ความล้มเหลวในการคอมไพล์สำหรับผ่านชัดเจน0และความล้มเหลวในการทำงานเวลาสำหรับการที่มีค่าchar*0

โปรดทราบว่าฉันไม่ได้หมายความว่าปกติแล้วควรทำเช่นนี้ แต่ไม่ต้องสงสัยเลยว่าอาจมีบางกรณีที่การป้องกันจากข้อผิดพลาดของผู้โทรถูกต้อง

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
}

ฉันพบปัญหานี้เมื่อไม่กี่ปีที่ผ่านมาและฉันพบว่ามันเป็นสิ่งที่น่ากลัวมากอย่างแน่นอน มันสามารถเกิดขึ้นได้โดยผ่าน a nullptrหรือโดยบังเอิญผ่าน int ด้วยค่า 0 มันไร้สาระจริงๆ:

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

อย่างไรก็ตามในท้ายที่สุดนี้เพียงฉัน bugged สองสามครั้ง และทุกครั้งที่มันทำให้เกิดความผิดพลาดทันทีเมื่อทดสอบรหัสของฉัน ดังนั้นไม่จำเป็นต้องทำการแก้ไขในช่วงกลางคืน

ฉันคิดว่าการใช้งานฟังก์ชั่นมากเกินไปconst char*เป็นความคิดที่ดี

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

ฉันหวังว่าจะเป็นทางออกที่ดีกว่า อย่างไรก็ตามไม่มี

วิธีเปลี่ยนลายเซ็นของวิธีการของคุณเป็น:

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

วิธีที่ผู้โทรต้องสร้างสตริงก่อนที่จะเรียกมันและความเลอะเทอะที่คุณกังวลจะทำให้เกิดปัญหาก่อนที่จะเข้าสู่วิธีการของคุณทำให้ชัดเจนสิ่งที่คนอื่น ๆ ชี้ให้เห็นว่าเป็นข้อผิดพลาดของผู้โทรไม่ใช่ของคุณ

วิธีการเกี่ยวกับคุณให้เกินพิกัดใช้intพารามิเตอร์?

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

private:
    void myMethod(int);

คุณไม่จำเป็นต้องกำหนดโอเวอร์โหลด การพยายามโทรออกmyMethod(0)จะทำให้เกิดข้อผิดพลาดของลิงเกอร์

(char *)0วิธีการของคุณในการป้องกันรหัสแรกจะไม่ถูกเรียกว่าถ้าคุณพยายามที่จะเรียกมันว่าด้วย C ++ จะพยายามสร้างสตริงและมันจะทำให้เกิดข้อยกเว้นสำหรับคุณ คุณลองหรือยัง

#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) 

ดู? คุณไม่มีอะไรต้องกังวล

ตอนนี้ถ้าคุณต้องการที่จะจับมันได้อย่างสวยงามยิ่งขึ้นคุณก็ไม่ควรใช้char *มันแล้วปัญหาก็จะไม่เกิดขึ้น

หากคุณกังวลว่าถ่าน * เป็นพอยน์เตอร์ที่อาจเป็นโมฆะ (เช่นผลตอบแทนจาก C API ภายนอก) คำตอบคือใช้ฟังก์ชัน const char * ของฟังก์ชันแทน std :: string one กล่าวคือ

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

แน่นอนว่าคุณจะต้องใช้ std :: string version เช่นกันหากคุณต้องการอนุญาตให้ใช้

โดยทั่วไปการแยกการเรียกไปยัง API ภายนอกและอาร์กิวเมนต์ marshal เป็นค่าที่ถูกต้อง