अंतिम अद्यतन：2026-10-12

C++ multiple return values लिखने के तरीके¶

आज एक और क्लासिक interview सवाल: फ़ंक्शन कैसे कई परिणाम लौटाए? आप कितने तरीके सोच सकते हैं?

दरअसल यह सवाल बहुत सारे knowledge points जाँचता है, जिनमें शामिल हैं:

पॉइंटर
रेफ़रेंस
lambda
functional
tie
tuple
struct bingding
template deduce
आदि

यह लेख आपको अलग-अलग तरीकों से यह प्रश्न हल करके दिखाएगा, सबसे पहले हम इस प्रश्न को बदलते हैं, a / b का उपयोग करके (नीचे dividend 0 होने की स्थिति नहीं मानी) quotient और remainder लौटाते हैं। सरल शब्दों में, एक फ़ंक्शन quotient और remainder लौटाने के कितने तरीके हैं?

अब मुख्य विषय में आते हैं, नोट: इस सेक्शन का सारा कोड पहली बार Knowledge Planet पर जारी हुआ है, रुचि हो तो नीचे का QR कोड स्कैन करें।

1. पॉइंटर और रेफ़रेंस¶

इंटरफ़ेस बदलकर दो वेरिएबल जोड़ें, पॉइंटर और रेफ़रेंस का उपयोग करें।

void divideWithReferences(int dividend, int divisor, int& quotient, int& remainder) {
  quotient = dividend / divisor;
  remainder = dividend % divisor;
}

void divideWithPointers(int dividend, int divisor, int* quotient, int* remainder) {
  if (quotient) *quotient = dividend / divisor;
  if (remainder) *remainder = dividend % divisor;
}

इस तरीके की कमी साफ़ दिखती है, जब दो से ज़्यादा return values हों, तो इंटरफ़ेस बहुत लंबा हो जाता है। इसके अलावा, अगर interviewer फ़ंक्शन इंटरफ़ेस बदलने की अनुमति न दे, तो यह तरीका उपयोग नहीं हो सकता।

2. Tuple + Tie¶

Tuple और tie का combination फ़ंक्शन के कई वैल्यू लौटाने का संक्षिप्त तरीका देता है। std::tie का उपयोग करके हम tuple के एलिमेंट्स को अलग-अलग वेरिएबल्स में unpack कर सकते हैं, जिससे कोड की स्पष्टता बढ़ती है।

यह तरीका standard answers में से एक है, काफ़ी सरल और साफ़, अगर return values दो हों तो pair भी चल सकता है।

std::tuple<int, int> divide(int dividend, int divisor) {
    return std::make_tuple(dividend / divisor, dividend % divisor);
}


std::tie(quotient, remainder) = divide(14, 3);
std::cout << quotient << ", " << remainder << std::endl;

3. Struct Binding¶

ऊपर वाले को बदलें, C++17 के structured binding ने multi-value return का कोड और सरल कर दिया। auto और structured binding का उपयोग करके कोड ज़्यादा सहज और समझने योग्य बनता है।

अगर interviewer आपसे ऊपर के तरीके में और सुधार माँगे, तो यह नीचे वाला कोड उदाहरण बन सकता है, structured binding का उपयोग करके कोड ज़्यादा एलिगेंट बनाया जा सकता है।

auto divide(int dividend, int divisor) {
  struct result {
    int quotient;
    int remainder;
  };
  return result{dividend / divisor, dividend % divisor};
}
auto [quotient, remainder] = divide(14, 3);

4. फ़ंक्शन Callback¶

रोज़मर्रा के प्रोजेक्ट्स में, ख़ासकर कुछ ओपन-सोर्स प्रोजेक्ट्स में, callback एक आम तरीका है, return values को संभालने वाला callback पास करके, यूज़र को अपने हिसाब से संभालने देना, इस तरह कई वैल्यू लौटाना हासिल होता है और ज़्यादा लचीला कोड स्ट्रक्चर मिलता है। यह asynchronous programming और event handling जैसे केस के लिए बहुत उपयोगी है।

void divide(int dividend, int divisor, std::function<void(int, int)> callback) {
  callback(dividend / divisor, dividend % divisor);
}

5. कस्टम Out¶

कस्टम out एक स्ट्रक्चर में wrap करने का तरीका है, जिसमें output पैरामीटर को स्ट्रक्चर का मेंबर बनाया जाता है। यह तरीका कोड की पठनीयता बढ़ाता है, ख़ासकर ऐसे फ़ंक्शनों के लिए जिन्हें कई वैल्यू लौटानी हों।

template <class T>
struct out {
  std::function<void(T)> target;

  out(T* t)
      : target([t](T&& in) {
          if (t) *t = std::move(in);
        }) {}

  template <class... Args>
  void emplace(Args&&... args) {
    target(T(std::forward<Args>(args)...));
  }

  template <class X>
  void operator=(X&& x) {
    emplace(std::forward<X>(x));
  }

  template <class... Args>
  void operator()(Args&&... args) {
    emplace(std::forward<Args>(args)...);
  }
};

void divide(int dividend, int divisor, out<int>& quotient_out, out<int>& remainder_out) {
  quotient_out.emplace(dividend / divisor);
  remainder_out.emplace(dividend % divisor);
}

6. टेम्पलेट deduction¶

C++ का template deduction डेवलपर्स को ज़्यादा लचीला और संक्षिप्त कोड लिखने का तरीका देता है। template deduction के ज़रिए हम अलग-अलग टाइप का डेटा संभाल सकते हैं, टाइप स्पष्ट रूप से बताए बिना।

template <typename T1, typename T2>
struct many {
  T1 quotient;
  T2 remainder;
};

template <class T1, class T2>
many(T1, T2) -> many<T1, T2>;

many<int, int> divide(int dividend, int divisor) {
  return many{
      dividend / divisor,
      dividend % divisor,
  };
}

auto [quotient, remainder] = divide(14, 3);

कुल मिलाकर, C++ multi-value return के कई तरीके देता है, हर तरीके के अपने उपयुक्त केस हैं। उपयुक्त तरीके का चुनावख़ास ज़रूरतों पर निर्भर है, डेवलपर कोड स्ट्रक्चर और पठनीयता के हिसाब से इन features का लचीले तरीके से उपयोग कर सकते हैं।