उपयोगकर्ता परिभाषित फ़ंक्शन से 3D सरणी कैसे वापस करें?

बस एक टिप्पणी: एक int *** एक 3D सरणी वापस करने के लिए उपयुक्त नहीं है। अधिक से अधिक इसका उपयोग पॉइंटर्स को पॉइंटर्स की सरणी में पॉइंटर्स के सरणी में वापस करने के लिए किया जा सकता है।

और चूंकि सी ++ भाषा में कच्चे सरणी प्रथम श्रेणी के तत्व नहीं हैं, इसलिए आप किसी फ़ंक्शन से एक साधारण प्राकृतिक तरीके से सरणी वापस नहीं कर सकते हैं।

क्या किया जा सकता है ?

1. सी ++ सरल तरीका:

   कच्चे सरणियों का उपयोग न करें लेकिन std::array अगर संकलन समय पर तय किया गया है, या std::vector अगर ऐसा नहीं है तो आकार है। फिर आप बना सकते हैं (और वेक्टर के वैक्टर या std::array std::array का। सावधान रहें कि वैक्टर का एक वेक्टर पॉइंटर्स की एक सरणी की तरह है: डेटा को सन्निहित होने की आवश्यकता नहीं है, इसलिए यह इसके बराबर नहीं है एक 3D सरणी। यहाँ, निश्चित आकार मानते हुए:

    std::array<std::array<std::array<int, 2>, 2>, 2> my_function(int a[], int b[], int c[])
    {
      std::array<std::array<std::array<int, 2>, 2>, 2> array;
      ...
      return array;
    }
   

2. एक कस्टम कंटेनर (अभी भी आधुनिक C++)

   यदि आपको C++ में एक 3D सन्निहित कंटेनर का अनुकरण करने की आवश्यकता है और इसे एक सामान्य वस्तु की तरह व्यवहार करना है (जिसे किसी फ़ंक्शन से वापस किया जा सकता है), तो आपको एक कस्टम कंटेनर और उसके एक्सेसर विधियों का निर्माण करना होगा। यह अत्यंत जटिल नहीं है, फिर भी यह तुच्छ से बहुत दूर है। यदि आप इस तरह से जाना चाहते हैं, तो मेरी सलाह है कि एक (1 डी) वेक्टर का उपयोग अंतर्निहित भंडारण के रूप में किया जाए ताकि कच्चे आवंटित भंडारण के साथ कॉपी, मूव, डिस्ट्रक्ट समस्या से परेशान न हों।

3. सी-ईश तरीका (कच्चे सरणी के साथ)।

   बहु-आयामी सरणियों में उनके सभी आयाम होने चाहिए, लेकिन अंतिम संकलन समय पर परिभाषित किया गया है। एक बार यह कहा जाने के बाद, आपको अभी भी 3 सामान्य सी स्टोरेज तरीके मिलते हैं: स्थिर भंडारण (सुरक्षित रूप से वापस किया जा सकता है, लेकिन थ्रेड सुरक्षित नहीं है), आवंटित भंडारण (थ्रेड सुरक्षित है, लेकिन कॉलर इसे मुक्त करने के लिए जिम्मेदार होगा), कॉलर प्रदान किया गया ( कॉलर सरणी बनाने और इसे कैली फ़ंक्शन में पास करने के लिए जिम्मेदार है। मैं आपको यहां तीसरा रास्ता दिखाऊंगा

    typedef int (*int3D)[2][2];
   
    int3D my_function(int a[], int b[], int c[], int3D array) {
    {
      for(int i=0; i<2; i++)
      {
        ...
      }
      return array;
    }
   

   उपयोग:

    int arr[2][2][2];
   
    int3D arr3D = my_function(a, b, c, arr);
    // after the call, arr3D == arr is true
   

आप std::array का उपयोग कर सकते हैं।

यदि आकार संकलित समय ज्ञात हैं, तो मैं std::array होने का सुझाव दूंगा, जिसके द्वारा आप सन्निहित मेमोरी लेआउट प्राप्त कर सकते हैं।

#include <iostream>
#include <array>
#include <algorithm> // std::generate

// alias for the required array
using Array3D = std::array<std::array<std::array<int, 2>, 2>, 2 >;

Array3D func()
{
   Array3D arr3d;
   std::array<int, 2> a{ 10, 20 }, b{ 10, 20 }, c{ 10, 20 }; // some a, b, c


   // iterate through the arrays to initialize them!
   auto input = 1u;
   for (std::array<std::array<int, 2>, 2> & array2D : arr3d) // or auto& array2D: arr3d
      for (std::array<int, 2> & arr : array2D)                // or auto& arr: array2D
         std::generate(arr.begin(), arr.end(), [&input] { return input++; });

   // for array multimplications!
   for (std::array<std::array<int, 2>, 2> & array2D : arr3d) // or auto& array2D
   {
      for (std::array<int, 2> & arr : array2D)               // or auto& arr
      {
         auto arrIndex = 0u;
         for (int& ele : arr)
         {
            ele = a[arrIndex] * b[arrIndex] * c[arrIndex];
            ++arrIndex;
            std::cout << ele << " "; // to print the element!
         }
      }
   }

   return arr3d; // return the array like this!
}

वैकल्पिक रूप से टेम्प्लेट किए गए फ़ंक्शन (गैर-टेम्पलेट पैरामीटर के रूप में आकार के साथ) का उपयोग करके, आप array3d को संदर्भ से भी पास कर सकते हैं और केवल ऊपर दिखाए गए गणनाओं को कर सकते हैं!

#include <iostream>

template<std::size_t M, std::size_t N, std::size_t O>
void func(int (&arr3d)[M][N][O])
{
   // some a, b, c

   for (std::size_t i = 0; i < M; ++i)
   {
      for (std::size_t j = 0; j < N; ++j)  
      {
         for (std::size_t k = 0; k < O; ++k)
         {
            arr3d[i][j][k] = a[k] * b[k] * c[k];
            std::cout << arr3d[i][j][k] << " "; // to print the element
         }
         std::cout << "\n";
      }
      std::cout << "\n";
   }
   // do not need to return!
}

जैसा कि अन्य ने उल्लेख किया है, आप std::array या std::vector का उपयोग कर सकते हैं लेकिन एक आसान तरीका है कि सरणी को अपने फ़ंक्शन में पैरामीटर के रूप में पास करना (वापसी के बजाय)। इस तरह:

void your_function(int array[2][2][2], /* other parameters */) {
    // body
}

और इसे इस तरह इस्तेमाल करें:

int main() {
    int arr[2][2][2];
    your_function(arr, /* other arguments */);
    // now do what you want with arr
}

मुझे वही मिला है जो आप चाहते थे

#include <iostream>
using namespace std;

int** form_2d_array(int l, int b)
{
    int **A = new int *[b];
    for (int i = 0; i < b; i++)
        A[i] = new int[l];
    return A;
}

int*** form_3d_array(int l, int b, int h)
{
    int ***A = new int **[h];
    for (int i = 0; i < h; i++)
        A[i] = form_2d_array(l,b);
    return A;
}

int main()
{
    int ***array;
    int l,b,h;
    l=3;b=5;h=3;
    array=form_3d_array(l,b,h);
    for (int i = 0; i < l; i++)
    {
        for (int j=0; j < b; j++)
        {
            for (int k=0; k < h; k++)
            {
                array[i][j][k] = i+j+k;
            }
        }
    }
    for (int k=0; k < h; k++)
    {
        cout<<"Printing "<<k+1<<"th matrix\n";
        for (int i = 0; i < l; i++)
        {
            for (int j=0; j < b; j++)
            {
                cout<<array[i][j][k]<<" ";
            }
            cout<<endl;
        }
        cout<<endl;
    }
    
    return 0;
}

2d सरणी फ़ंक्शन 2d सरणी देता है और 3d सरणी फ़ंक्शन 3d सरणी देता है।