C में फ़ंक्शन तर्क के रूप में बहुआयामी सरणियों को पास करना

original title: "Passing multidimensional arrays as function arguments in C"


Translate

In C can I pass a multidimensional array to a function as a single argument when I don't know what the dimensions of the array are going to be ?

In addition my multidimensional array may contain types other than strings.



C में क्या मैं एक एकल तर्क के रूप में एक फ़ंक्शन के लिए एक बहुआयामी सरणी पास कर सकता हूं जब मुझे नहीं पता कि सरणी के आयाम क्या होने जा रहे हैं? इसके अलावा मेरे बहुआयामी सरणी में हो सकता है ...

यह अनुवाद के बाद का सारांश है, अगर आपको पूरा अनुवाद देखने की आवश्यकता है, तो कृपया 'अनुवाद' आइकन पर क्लिक करें


सभी उत्तर
  • Translate

    You can do this with any data type. Simply make it a pointer-to-pointer:

    typedef struct {
      int myint;
      char* mystring;
    } data;
    
    data** array;
    

    But don't forget you still have to malloc the variable, and it does get a bit complex:

    //initialize
    int x,y,w,h;
    w = 10; //width of array
    h = 20; //height of array
    
    //malloc the 'y' dimension
    array = malloc(sizeof(data*) * h);
    
    //iterate over 'y' dimension
    for(y=0;y<h;y++){
      //malloc the 'x' dimension
      array[y] = malloc(sizeof(data) * w);
    
      //iterate over the 'x' dimension
      for(x=0;x<w;x++){
        //malloc the string in the data structure
        array[y][x].mystring = malloc(50); //50 chars
    
        //initialize
        array[y][x].myint = 6;
        strcpy(array[y][x].mystring, "w00t");
      }
    }
    

    The code to deallocate the structure looks similar - don't forget to call free() on everything you malloced! (Also, in robust applications you should check the return of malloc().)

    Now let's say you want to pass this to a function. You can still use the double pointer, because you probably want to do manipulations on the data structure, not the pointer to pointers of data structures:

    int whatsMyInt(data** arrayPtr, int x, int y){
      return arrayPtr[y][x].myint;
    }
    

    Call this function with:

    printf("My int is %d.\n", whatsMyInt(array, 2, 4));
    

    Output:

    My int is 6.
    

  • Translate

    Pass an explicit pointer to the first element with the array dimensions as separate parameters. For example, to handle arbitrarily sized 2-d arrays of int:

    void func_2d(int *p, size_t M, size_t N)
    {
      size_t i, j;
      ...
      p[i*N+j] = ...;
    }
    

    which would be called as

    ...
    int arr1[10][20];
    int arr2[5][80];
    ...
    func_2d(&arr1[0][0], 10, 20);
    func_2d(&arr2[0][0], 5, 80);
    

    Same principle applies for higher-dimension arrays:

    func_3d(int *p, size_t X, size_t Y, size_t Z)
    {
      size_t i, j, k;
      ...
      p[i*Y*Z+j*Z+k] = ...;
      ...
    }
    ...
    arr2[10][20][30];
    ...
    func_3d(&arr[0][0][0], 10, 20, 30);
    

  • Translate

    You can declare your function as:

    f(int size, int data[][size]) {...}
    

    The compiler will then do all pointer arithmetic for you.

    Note that the dimensions sizes must appear before the array itself.

    GNU C allows for argument declaration forwarding (in case you really need to pass dimensions after the array):

    f(int size; int data[][size], int size) {...}
    

    The first dimension, although you can pass as argument too, is useless for the C compiler (even for sizeof operator, when applied over array passed as argument will always treat is as a pointer to first element).


  • Translate
    int matmax(int **p, int dim) // p- matrix , dim- dimension of the matrix 
    {
        return p[0][0];  
    }
    
    int main()
    {
       int *u[5]; // will be a 5x5 matrix
    
       for(int i = 0; i < 5; i++)
           u[i] = new int[5];
    
       u[0][0] = 1; // initialize u[0][0] - not mandatory
    
       // put data in u[][]
    
       printf("%d", matmax(u, 0)); //call to function
       getche(); // just to see the result
    }