คุณสร้างสตริง std :: ด้วย null ฝังได้อย่างไร

หากฉันต้องการสร้าง std :: string ด้วยบรรทัดเช่น:

std::string my_string("a\0b");

โดยที่ฉันต้องการให้มีอักขระสามตัวในสตริงผลลัพธ์ (a, null, b) ฉันจะได้เพียงตัวเดียว ไวยากรณ์ที่เหมาะสมคืออะไร?

ตั้งแต่ C ++ 14

เราสามารถสร้างตัวอักษรได้ std::string

#include <iostream>
#include <string>

int main()
{
    using namespace std::string_literals;

    std::string s = "pl-\0-op"s;    // <- Notice the "s" at the end
                                    // This is a std::string literal not
                                    // a C-String literal.
    std::cout << s << "\n";
}

ก่อน C ++ 14

ปัญหาคือตัวstd::stringสร้างที่const char*สมมติว่าอินพุตเป็นสตริง C สตริง C ถูก\0ยกเลิกและการแยกวิเคราะห์จะหยุดเมื่อถึง\0อักขระ

เพื่อชดเชยสิ่งนี้คุณต้องใช้ตัวสร้างที่สร้างสตริงจากอาร์เรย์ถ่าน (ไม่ใช่ C-String) สิ่งนี้ใช้สองพารามิเตอร์ - ตัวชี้ไปยังอาร์เรย์และความยาว:

std::string   x("pq\0rs");   // Two characters because input assumed to be C-String
std::string   x("pq\0rs",5); // 5 Characters as the input is now a char array with 5 characters.

หมายเหตุ: C ++ std::stringจะไม่ \0 -terminated (ตามข้อเสนอแนะในการโพสต์อื่น ๆ ) อย่างไรก็ตามคุณสามารถดึงตัวชี้ไปยังบัฟเฟอร์ภายในที่มี C-String c_str()กับวิธีการ

ตรวจสอบคำตอบของ Doug Tด้านล่างเกี่ยวกับการใช้ไฟล์vector<char>.

ตรวจสอบRiaDสำหรับโซลูชัน C ++ 14

หากคุณกำลังทำการปรับแต่งเช่นเดียวกับที่คุณทำกับสตริงสไตล์ c (อาร์เรย์ของอักขระ) ให้พิจารณาใช้

std::vector<char>

คุณมีอิสระมากขึ้นในการปฏิบัติเหมือนอาร์เรย์ในลักษณะเดียวกับที่คุณปฏิบัติต่อ c-string คุณสามารถใช้ copy () เพื่อคัดลอกลงในสตริง:

std::vector<char> vec(100)
strncpy(&vec[0], "blah blah blah", 100);
std::string vecAsStr( vec.begin(), vec.end());

และคุณสามารถใช้มันได้ในหลาย ๆ ที่เดียวกันคุณสามารถใช้ c-strings ได้

printf("%s" &vec[0])
vec[10] = '\0';
vec[11] = 'b';

อย่างไรก็ตามคุณประสบปัญหาเช่นเดียวกับ c-strings คุณอาจลืมเทอร์มินัลว่างของคุณหรือเขียนผ่านพื้นที่ที่จัดสรรไว้

ฉันไม่รู้ว่าทำไมคุณถึงต้องการทำสิ่งนั้น แต่ลองทำสิ่งนี้:

std::string my_string("a\0b", 3);

ความสามารถใหม่ใดที่ผู้ใช้กำหนดเองเพิ่มให้กับ C ++ นำเสนอคำตอบที่สวยงาม: กำหนด

std::string operator "" _s(const char* str, size_t n) 
{ 
    return std::string(str, n); 
}

จากนั้นคุณสามารถสร้างสตริงของคุณด้วยวิธีนี้:

std::string my_string("a\0b"_s);

หรือแม้แต่:

auto my_string = "a\0b"_s;

มีวิธี "แบบเก่า":

#define S(s) s, sizeof s - 1 // trailing NUL does not belong to the string

จากนั้นคุณสามารถกำหนด

std::string my_string(S("a\0b"));

ต่อไปนี้จะทำงาน ...

std::string s;
s.push_back('a');
s.push_back('\0');
s.push_back('b');

คุณจะต้องระวังเรื่องนี้ หากคุณแทนที่ 'b' ด้วยอักขระตัวเลขใด ๆ คุณจะสร้างสตริงผิดโดยไม่ใช้วิธีการส่วนใหญ่ ดู: กฎสำหรับ C ++ อักษรของสตริงหนีตัวอักษร

ตัวอย่างเช่นฉันทิ้งตัวอย่างข้อมูลที่ดูไร้เดียงสานี้ลงกลางโปรแกรม

// Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
    std::cerr << c;
    // 'Q' is way cooler than '\0' or '0'
    c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
    std::cerr << c;
}
std::cerr << "\n";

นี่คือผลลัพธ์ของโปรแกรมนี้สำหรับฉัน:

Entering loop.
Entering loop.

vector::_M_emplace_ba
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ

นั่นเป็นคำสั่งพิมพ์ครั้งแรกของฉันสองครั้งอักขระที่ไม่ได้พิมพ์หลายตัวตามด้วยขึ้นบรรทัดใหม่ตามด้วยบางสิ่งในหน่วยความจำภายในซึ่งฉันเพิ่งเขียนทับ (แล้วพิมพ์แสดงว่ามีการเขียนทับ) ที่แย่ที่สุดคือรวบรวมสิ่งนี้ด้วยคำเตือน gcc อย่างละเอียดและละเอียดทำให้ฉันไม่มีข้อบ่งชี้ว่ามีบางอย่างผิดปกติและการเรียกใช้โปรแกรมผ่าน valgrind ไม่ได้บ่นเกี่ยวกับรูปแบบการเข้าถึงหน่วยความจำที่ไม่เหมาะสม กล่าวอีกนัยหนึ่งก็คือเครื่องมือที่ทันสมัยไม่สามารถตรวจจับได้อย่างสมบูรณ์

คุณจะได้รับปัญหาเดียวกันนี้ด้วยวิธีที่ง่ายกว่ามาก std::string("0", 100);แต่ตัวอย่างข้างต้นค่อนข้างยุ่งยากกว่าเล็กน้อยและทำให้ยากที่จะดูว่ามีอะไรผิดปกติ

โชคดีที่ C ++ 11 ช่วยให้เราแก้ปัญหาได้ดีโดยใช้ไวยากรณ์รายการตัวเริ่มต้น วิธีนี้ช่วยให้คุณไม่ต้องระบุจำนวนอักขระ (ซึ่งตามที่ฉันได้แสดงไว้ข้างต้นคุณสามารถทำได้ไม่ถูกต้อง) และหลีกเลี่ยงการรวมตัวเลขที่หลีกเลี่ยง std::string str({'a', '\0', 'b'})ปลอดภัยสำหรับเนื้อหาสตริงต่างจากเวอร์ชันที่ใช้อาร์เรย์charและขนาด

ใน C ++ 14 ตอนนี้คุณสามารถใช้ตัวอักษรได้แล้ว

using namespace std::literals::string_literals;
std::string s = "a\0b"s;
std::cout << s.size(); // 3

ควรใช้ std :: vector <char> หากคำถามนี้ไม่ได้มีไว้เพื่อการศึกษาเท่านั้น

คำตอบของ anonym นั้นยอดเยี่ยม แต่ก็มีโซลูชันที่ไม่ใช่มาโครใน C ++ 98 เช่นกัน:

template <size_t N>
std::string RawString(const char (&ch)[N])
{
  return std::string(ch, N-1);  // Again, exclude trailing `null`
}

ด้วยฟังก์ชันนี้RawString(/* literal */)จะสร้างสตริงเดียวกันกับS(/* literal */):

std::string my_string_t(RawString("a\0b"));
std::string my_string_m(S("a\0b"));
std::cout << "Using template: " << my_string_t << std::endl;
std::cout << "Using macro: " << my_string_m << std::endl;

นอกจากนี้ยังมีปัญหากับมาโคร: นิพจน์ไม่ได้เป็นจริงstd::stringตามที่เขียนดังนั้นจึงไม่สามารถใช้งานได้เช่นสำหรับการกำหนดค่าเริ่มต้นอย่างง่าย:

std::string s = S("a\0b"); // ERROR!

... ดังนั้นจึงควรใช้:

#define std::string(s, sizeof s - 1)

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

ฉันรู้ว่าคำถามนี้ถูกถามมานานแล้ว แต่สำหรับใครก็ตามที่มีปัญหาคล้าย ๆ กันอาจสนใจโค้ดต่อไปนี้

CComBSTR(20,"mystring1\0mystring2\0")

การใช้งาน std :: strings เกือบทั้งหมดถูกยกเลิกด้วย null ดังนั้นคุณอาจไม่ควรทำเช่นนี้ โปรดทราบว่าจริงๆแล้ว "a \ 0b" มีความยาวสี่อักขระเนื่องจากตัวบอกเลิกโมฆะอัตโนมัติ (a, null, b, null) หากคุณต้องการทำสิ่งนี้จริงๆและทำลายสัญญาของ std :: string คุณสามารถทำได้:

std::string s("aab");
s.at(1) = '\0';

แต่ถ้าคุณทำเพื่อนของคุณจะหัวเราะเยาะคุณคุณจะไม่มีวันพบกับความสุขที่แท้จริง