เหตุใด #include <string> จึงป้องกันข้อผิดพลาดสแต็กล้นที่นี่

นี่คือรหัสตัวอย่างของฉัน:

#include <iostream>
#include <string>
using namespace std;

class MyClass
{
    string figName;
public:
    MyClass(const string& s)
    {
        figName = s;
    }

    const string& getName() const
    {
        return figName;
    }
};

ostream& operator<<(ostream& ausgabe, const MyClass& f)
{
    ausgabe << f.getName();
    return ausgabe;
}

int main()
{
    MyClass f1("Hello");
    cout << f1;
    return 0;
}

ถ้าผมแสดงความคิดเห็นออก#include <string>ฉันไม่ได้รับรวบรวมข้อผิดพลาดใด ๆ #include <iostream>ผมคิดว่าเพราะมันเป็นชนิดของการรวมผ่าน ถ้าฉัน"คลิกขวา -> ไปที่คำจำกัดความ"ใน Microsoft VS ทั้งคู่ชี้ไปที่บรรทัดเดียวกันในxstringไฟล์:

typedef basic_string<char, char_traits<char>, allocator<char> >
    string;

แต่เมื่อฉันเรียกใช้โปรแกรมฉันได้รับข้อผิดพลาดข้อยกเว้น:

0x77846B6E (ntdll.dll) ใน OperatorString.exe: 0xC00000FD: Stack overflow (พารามิเตอร์: 0x00000001, 0x01202FC4)

ความคิดว่าทำไมฉันจะได้รับข้อผิดพลาด runtime เมื่อแสดงความคิดเห็นออกมา#include <string>? ฉันใช้ VS 2013 Express

พฤติกรรมที่น่าสนใจมาก

มีความคิดว่าทำไมฉันถึงได้รับข้อผิดพลาดรันไทม์เมื่อแสดงความคิดเห็น #include <string>

ด้วยคอมไพเลอร์ MS VC ++ ข้อผิดพลาดเกิดขึ้นเพราะถ้าคุณไม่ทำ#include <string>คุณจะไม่ได้operator<<กำหนดไว้สำหรับstd::string.

เมื่อคอมไพเลอร์พยายามที่จะรวบรวมausgabe << f.getName();มันก็ดูการกำหนดไว้สำหรับoperator<< std::stringเนื่องจากไม่ได้กำหนดไว้คอมไพลเลอร์จึงมองหาทางเลือกอื่น มีการoperator<<กำหนดไว้สำหรับMyClassและคอมไพเลอร์พยายามที่จะใช้และการใช้งานจะต้องแปลงstd::stringเป็นMyClassและนี่คือสิ่งที่เกิดขึ้นเนื่องจากMyClassมีตัวสร้างที่ไม่ชัดเจน! ดังนั้นคอมไพเลอร์จะสร้างอินสแตนซ์ใหม่ของคุณMyClassและพยายามสตรีมอีกครั้งไปยังสตรีมเอาต์พุตของคุณ สิ่งนี้ส่งผลให้เกิดการเรียกซ้ำไม่รู้จบ:

 start:
     operator<<(MyClass) -> 
         MyClass::MyClass(MyClass::getName()) -> 
             operator<<(MyClass) -> ... goto start;

เพื่อหลีกเลี่ยงข้อผิดพลาดที่คุณจำเป็นต้อง#include <string>ตรวจสอบให้แน่ใจว่ามีการกำหนดไว้สำหรับoperator<< std::stringนอกจากนี้คุณควรกำหนดให้ตัวสร้างของคุณMyClassชัดเจนเพื่อหลีกเลี่ยงการแปลงที่ไม่คาดคิดประเภทนี้ กฎแห่งปัญญา: ทำให้ตัวสร้างมีความชัดเจนหากพวกเขาใช้อาร์กิวเมนต์เดียวเพื่อหลีกเลี่ยงการแปลงโดยปริยาย:

class MyClass
{
    string figName;
public:
    explicit MyClass(const string& s) // <<-- avoid implicit conversion
    {
        figName = s;
    }

    const string& getName() const
    {
        return figName;
    }
};

ดูเหมือนว่าoperator<<สำหรับการstd::stringได้รับการกำหนดไว้เฉพาะเมื่อ<string>รวมอยู่ (กับคอมไพเลอร์ MS) และที่รวบรวมเหตุผลทุกอย่าง แต่คุณจะได้รับพฤติกรรมค่อนข้างไม่คาดคิดoperator<<จะได้รับการเรียกซ้ำสำหรับMyClassแทนการโทรสำหรับoperator<<std::string

นั่นหมายความว่าผ่าน#include <iostream>สตริงจะรวมเพียงบางส่วนหรือไม่?

ไม่สตริงถูกรวมไว้อย่างสมบูรณ์มิฉะนั้นคุณจะไม่สามารถใช้งานได้

ปัญหาคือโค้ดของคุณกำลังทำการเรียกซ้ำไม่สิ้นสุด ตัวดำเนินการสตรีมสำหรับstd::string( std::ostream& operator<<(std::ostream&, const std::string&)) ถูกประกาศใน<string>ไฟล์ส่วนหัวแม้ว่าจะstd::stringมีการประกาศตัวเองในไฟล์ส่วนหัวอื่น ๆ (รวมทั้ง<iostream>และ<string>)

เมื่อคุณไม่ได้รวมถึงคอมไพเลอร์พยายามที่จะหาวิธีที่จะรวบรวม<string>ausgabe << f.getName();

มันเกิดขึ้นที่คุณได้กำหนดทั้งตัวดำเนินการสตรีมMyClassและตัวสร้างที่ยอมรับ a std::stringดังนั้นคอมไพเลอร์จึงใช้มัน (ผ่านการสร้างโดยนัย ) สร้างการเรียกซ้ำ

หากคุณประกาศตัวexplicitสร้างของคุณ ( explicit MyClass(const std::string& s)) โค้ดของคุณจะไม่คอมไพล์อีกต่อไปเนื่องจากไม่มีวิธีใดที่จะโทรหาตัวดำเนินการสตรีมด้วยstd::stringและคุณจะต้องรวม<string>ส่วนหัว

แก้ไข

สภาพแวดล้อมการทดสอบของฉันคือ VS 2010 และเริ่มต้นที่ระดับการเตือน 1 ( /W1) จะเตือนคุณเกี่ยวกับปัญหา:

คำเตือน C4717: 'operator <<': เรียกซ้ำในเส้นทางควบคุมทั้งหมดฟังก์ชันจะทำให้รันไทม์สแตกล้น