सी में त्रुटि प्रबंधन के साथ स्ट्रिंग्स को पूर्णांकों में परिवर्तित करना

प्रोग्रामिंग में, स्ट्रिंग्स को पूर्णांकों में परिवर्तित करना अक्सर आवश्यक होता है। जबकि C इस उद्देश्य के लिए std::atoi फ़ंक्शन प्रदान करता है, यह रूपांतरण त्रुटियों को शालीनता से नहीं संभालता है। इसे संबोधित करने के लिए, हम एक ऐसा समाधान खोज रहे हैं जो C# के Int32.TryParse के समान त्रुटि प्रबंधन की अनुमति देता है।

बूस्ट का लेक्सिकल कास्ट फ़ंक्शन

एक कुशल तरीका बूस्ट लाइब्रेरी से लेक्सिकल_कास्ट फ़ंक्शन का उपयोग करना है . यह विभिन्न प्रकार के डेटा प्रकारों का समर्थन करता है और कास्ट विफल होने पर अपवाद फेंक सकता है। यहाँ एक उदाहरण है:

#include 

int main() {
    std::string s;
    std::cin >> s;

    try {
        int i = boost::lexical_cast(s);

        // ...
    } catch (...) {
        // Handle error
    }
}

मानक लाइब्रेरी फ़ंक्शंस का उपयोग करना

यदि बूस्ट उपलब्ध नहीं है, तो std::stringstream और >> ऑपरेटर के संयोजन का उपयोग किया जा सकता है:

#include 
#include 
#include 

int main() {
    std::string s;
    std::cin >> s;

    try {
        std::stringstream ss(s);

        int i;
        if ((ss >> i).fail() || !(ss >> std::ws).eof()) {
            throw std::bad_cast();
        }

        // ...
    } catch (...) {
        // Handle error
    }
}

बूस्ट के लेक्सिकल कास्ट को नकली बनाना

अंतिम विकल्प के रूप में, बूस्ट के लेक्सिकल_कास्ट फ़ंक्शन का एक "नकली" संस्करण बनाया जा सकता है:

#include 
#include 
#include 

template 
T lexical_cast(const std::string& s) {
    std::stringstream ss(s);

    T result;
    if ((ss >> result).fail() || !(ss >> std::ws).eof()) {
        throw std::bad_cast();
    }

    return result;
}

int main() {
    std::string s;
    std::cin >> s;

    try {
        int i = lexical_cast(s);

        // ...
    } catch (...) {
        // Handle error
    }
}

नो-थ्रो संस्करण

यदि नो-थ्रो संस्करण वांछित है, तो उचित अपवाद पकड़ें और सफलता या विफलता का संकेत देने वाला एक बूलियन लौटाएं:

template 
bool lexical_cast(const std::string& s, T& t) {
    try {
        t = lexical_cast(s);
        return true;
    } catch (const std::bad_cast& e) {
        return false;
    }
}

int main() {
    std::string s;
    std::cin >> s;

    int i;
    if (!lexical_cast(s, i)) {
        std::cout