अपवाद हैंडलिंग प्रदर्शित करने के लिए C++ प्रोग्राम

मान लीजिए कि एक फ़ंक्शन है जो कुछ गंभीर जटिल गणितीय कार्यों की गणना करता है। लेकिन ऑपरेशन के दौरान कुछ अपवाद हो सकते हैं। हमें विभिन्न प्रकार के अपवादों को संभालना होगा जो हो सकते हैं और निम्नलिखित कार्य कर सकते हैं।

• यदि कंप्यूटर गणना के लिए मेमोरी आवंटित करने में असमर्थ है, तो हमें 'मेमोरी लो!' प्रिंट करना होगा।
• यदि कोई अन्य C++-संबंधित अपवाद होता है, तो हमें अपवाद के बाद 'अपवाद:' प्रिंट करना होगा।
• अगर कुछ और होता है, तो हम 'अनहेल्ड अपवाद' प्रिंट करते हैं।

हमें एक सरणी दी जाती है जिसमें मानों की एक जोड़ी होती है, और हम इसे फ़ंक्शन में पास करते हैं। यदि कोई अपवाद होता है, तो हम इसे संभालते हैं, या अन्यथा, हम आउटपुट मान प्रिंट करते हैं।

हमें केवल अपवादों को उत्पन्न करने वाले फ़ंक्शन के तंत्र की अवहेलना करते हुए अपवादों को संभालना है।

इसलिए, यदि इनपुट arr ={{361643035132, 2297873642249}, {-17, 15}}; जैसा है, तो आउटपुट होगा -

Memory Low!
Exception: val1 is negative

मानों की पहली जोड़ी को संभालने के लिए बहुत बड़ा है, इसलिए 'मेमोरी लो' प्रिंट होता है। दूसरी जोड़ी का पहला मान ऋणात्मक है। प्रदान किया गया फ़ंक्शन उसके साथ काम नहीं कर सकता है, इसलिए यह एक अपवाद उत्पन्न/फेंकता है 'val1 is नकारात्मक',

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

• इनिशियलाइज़ i :=0 के लिए, जब i करें
• val1:=मान[i, 0]
• val2 :=value[i, 1]
• कोशिश करें,
  • प्रिंट (foo(val1, val2))
• यदि स्मृति आवंटित नहीं की जा सकती (bad_alloc अपवाद पकड़ा जाता है), तो
  • प्रिंट ("मेमोरी लो!")
• अन्यथा, यदि कोई अन्य मानक C++ अपवाद e पकड़ा जाता है, तो
  • प्रिंट ("अपवाद:")
  • अपवाद का विवरण प्रिंट करें
• अन्यथा यदि कोई अन्य अपवाद पकड़ा जाता है, तो
  • प्रिंट ("अनहेल्ड अपवाद")

उदाहरण

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

#include <iostream>
#include <exception>
#include <string>
#include <stdexcept>
#include <vector>
#include <cmath>
using namespace std;

class Solution {
private:
   static int value;
public:
   static int foo(long long val1, long long val2) {
      value += 1;
      if(val1 < 0) {
         throw std::invalid_argument("val1 is negative");
      }
      vector<int> vectorList(val1, 0);
      int r = -1, c = sqrt(-1);
      if(val2 == 0) throw 0;
      r = (val1 / val2) * r;
      int ans = vectorList.at(val2);
      return r + val1 - val2 * ans;
   }
   static int getVal() {
      return value;
   }
};
int Solution::value = 0;

void solve(int t, long int values[][2]) {
   for (int i = 0; i < t; i++) {
      long long val1, val2;
      val1 = values[i][0];
      val2 = values[i][1];
      try {
         cout << Solution::foo(val1, val2) << '\n';
      }
      catch (const std::bad_alloc&) {
         cout << "Memory Low!\n";
      }
      catch (const std::exception& e) {
         cout << "Exception: " << e.what() << '\n';
      }
      catch (...) {
         cout << "Unhandled Exception\n";
      }
   }
}
int main() {
   long int arr[][2] = {{361643035132, 2297873642249}, {-17, 15}};
   solve(2, arr);
}

इनपुट

long int arr[][2] = {{361643035132, 2297873642249}, {-17, 15}};
solve(2, arr);

आउटपुट

Memory Low!
Exception: val1 is negative