क्या कोई ऐसा फ़ंक्शन लिखना संभव है जो एन आयामों की सरणी ले सकता है?

Question

मैं एक ऐसा फ़ंक्शन लिखने की कोशिश कर रहा हूं जो सरणी में सफलतापूर्वक सरणी में किसी भी आयाम और प्रिंट मानों का सरणी ले सकता है। लेकिन मैं आगे बढ़ने में सक्षम नहीं हूं क्योंकि हमें कार्य को घोषित करते समय सबसे अधिक छोड़कर सभी आयामों को घोषित करना होगा। क्या कोई संभावना है कि हम एक सामान्यीकृत कार्य लिख सकते हैं जो किसी भी आयाम के लिए इनपुट के रूप में सरणी ले सकता है?

उदाहरण के लिए, फ़ंक्शन 2 आयामी सरणी या 3 आयामी सरणी या एन आयामी सरणी लेने में सक्षम होना चाहिए जहां n कोई संख्या है।

Answer 1

, प्रत्येक आयाम और टेम्पलेट (ताकि C++) के लिए प्रत्यावर्तन का उपयोग करने से निम्नलिखित:

template <typename T> 
void print(const T&e) 
{ 
    std::cout << e << " "; 
} 

template <typename T, std::size_t N> 
void print(const T (&a)[N]) 
{ 
    std::cout << "{"; 
    for (const auto& e : a) { 
     print(e); 
    } 
    std::cout << "}" << std::endl; 
} 

उदाहरण उपयोग:

int a[2][3][4]; 
print(a); 

Live example

Answer 2

यदि आप कोड को एक-आयामी के रूप में सरणी करते हैं और फिर स्वयं को एक इंडेक्स की गणना करते हैं, तो आप निश्चित रूप से एक प्रोग्राम एक्ट कर सकते हैं जैसे सरणी एक चरणीय आयामों के लिए बनाई गई थी।

मेरा प्रारंभिक हालांकि यह कैसे करना है कि वेक्टर के साथ शुरू करना होगा जिसमें प्रत्येक आयाम की सीमा है जिसमें आप उपयोग करना चाहते हैं।

उस वेक्टर में तत्वों की संख्या आपके आयामों की संख्या होगी।

Answer 3

एक सरणी में भेजा जाता है सरणी की आयामता के बावजूद सरणी तत्वों के प्रकार के लिए एक सूचक के रूप में एक कार्य। प्रत्येक आयाम में तत्वों की संख्या निर्दिष्ट करने के लिए आयाम, एन, और एक सरणी (एक और एक) की संख्या निर्दिष्ट करने के लिए आपके पास और तर्क हो सकते हैं। ध्यान दें कि [] नोटेशन पॉइंटर अतिरिक्त प्रदर्शन करने का एक आसान तरीका है।

Answer 4

मुझे यकीन है कि यह सी मानक के कम से कम एक नियम का उल्लंघन करता है लेकिन इसे अभ्यास में काम करना चाहिए। ध्यान दें कि यह सरणी के किसी भी स्तर के समापन तत्व के लिए एक सेंटीनेल मान के रूप में 0 का उपयोग करता है।

void print(void* p, int dim) 
{ 
    if (dim == 1) 
    { 
     int* a = (int*) p; 
     while (*a) 
     { 
      printf("%d ", *a++); 
     } 
     printf("\n"); 
    } 
    else 
    { 
     void** a = (void**)p; 
     while (*a) 
     { 
      print(*a++, dim - 1); 
     } 
    } 
} 

void test() 
{ 
    int x0 [] = { 11, 12, 13, 14, 15, 0 }; 
    int x1 [] = { 21, 22, 23, 0 }; 
    int x2 [] = { 0 }; 
    int x3 [] = { 41, 42, 0 }; 
    int x4 [] = { 51, 52, 53, 0 }; 
    int* y0 [] = { x0, x3, 0 }; 
    int* y1 [] = { 0 }; 
    int* y2 [] = { x1, x2, x4, 0 }; 
    int** z [] = { y0, y1, y2, 0 }; 

    print(z, 3); 
} 

प्रिंटों:

11 12 13 14 15 
41 42 
21 22 23 

51 52 53 

Answer 5

आप विशेष तत्व का उपयोग या सरणी पर काम करना चाहते हैं लेकिन आप गतिशील मैट्रिक्स बनाना चाहते हैं, तो आप को पारित करके प्रत्येक तत्व का उपयोग करने के उपयोग संकेत का उपयोग कर सकते हैं प्रिंट फ़ंक्शन में आयाम।

के बाद से यदि आप एक बहुआयामी सरणी int [][] रूप में परिभाषित किया है, तो x = y[a][b]-x = *((int *)y + a * NUMBER_OF_COLUMNS + b);

चेक अधिक जानकारी के लिए इस पोस्ट के बराबर है: How to use pointer expressions to access elements of a two-dimensional array in C?

तो, अगर आप पूरे मैट्रिक्स प्रिंट या किसी तक पहुंचना चाहते हैं विशेष तत्व, आप कर सकते हैं की तरह: उपरोक्त कार्यक्रम के लिए

#include <iostream> 
using namespace std; 

//the function print_2D_matrix receives 4 arguments: pointer to first element 
//             dimension of array arr, i.e. n x m 
//             index of the element to be printed, i.e. a and b 
void print_2D_matrix(int *arr, int n, int m, int a, int b){ 
    for(int i = 0; i < n; i++){ 
     for(int j = 0; j < m; j++) 
      printf("%d ", *(arr + (i * m) + j)); 
     printf("\n"); 
    } 
    //go to the address just before a row, i.e. (a - 1) * NO_OF_COLUMNS 
    //then go to the address on b column, i.e. (a - 1) * NO_OF_COLUMNS + b 
    //since we started from the base address, i.e. first element(arr[0][0]), subtract 1 
    printf("arr[3][3] = %d\n", *(arr + ((a - 1) * m) + b - 1)); //print arr[a][b] 
} 

int main() { 
    int n, m; 
    cin>>n>>m; 
    int arr[n][m]; 

    for(int i = 0; i < n; i++) //initialize the matrix 
     for(int j = 0; j < m; j++) 
      arr[i][j] = i * j; 

    print_2D_matrix((int *) arr, n, m, 3, 3); 

    return 0; 
} 

आउटपुट (nxm के लिए = 4 x 5) है:

0 0 0 0 0 
0 1 2 3 4 
0 2 4 6 8 
0 3 6 9 12 
arr[3][3] = 4