Array as parameter C++

My solution:

#include <iostream>
#include <stdlib.h>
#include <time.h>

using namespace std;

void generarArreglo(int **matriz, int rows, int cols){
    srand(time(NULL));
    for(int i=0;i<rows;i++){
        for(int j=0;j<cols;j++){
            matriz[i][j]=rand()%99+1;
        }
    }
}

void imprimirArreglo(int **matriz, int rows, int cols){
    for(int i=0;i< rows;i++){
        for(int j=0;j< cols;j++){
            cout<<matriz[i][j]<<"\t";
        }
        cout<<endl;
    }
}

int main(){
    int n;
    cin >> n;
    int rows , cols;
    rows = cols = n;
    int** matriz = new int*[rows];
    for (int i = 0; i < rows; ++i)
        matriz[i] = new int[cols];
    generarArreglo(matriz, rows, cols);
    imprimirArreglo(matriz, rows, cols);
    return 0;
}

Entry:

4

Departure:

98  79  6   19  
11  2   96  95  
63  33  11  93  
80  36  70  50

The error is occurring here:

void generarArreglo(int matriz[n][n]){ // <<--- AQUI!!!
  // ...
}

void imprimirArreglo(int matriz[n][n]){ // <<--- AQUI!!!

And the reason is that nit does not exist for those functions. If it were a constant value known at compile time you could patch the code such that:

const int n = 5;

void generarArreglo(int matriz[n][n]){ // OK
  // ...
}

But is not the case. As you have already been proposed a solution using an array based on double pointers, I propose a similar solution with simple pointers... or with a single vector. The advantage of using STL containers is that you avoid dealing with heap memory, which is usually a big relief:

void generarArreglo(std::vector<int>& matriz){
  srand(time(NULL));
  for( int i=0; i<matriz.size(); i++)
    matriz[i]=rand()%99+1;
}

void imprimirArreglo(std::vector<int>& matriz, int n){
  for(int i=0;i<n;i++){
    for(int j=0;j<n;j++){
      cout<<matriz[i*n+j]<<'\t';
    }
    cout<<'\n';
  }
}

int main(){
  int n;
  cin >> n;
  std::vector<int> matriz(n*n,0);
  generarArreglo(matriz);
  imprimirArreglo(matriz, n);
  system("pause");
  return 0;
}

And the same could be achieved with a single pointer... the advantages over a double pointer are basically two:

• Only one reservation and one release required
• The memory is all pooled, which favors the use of the system cache.

Example with simple pointer:

void generarArreglo(int* matriz, int length){
  srand(time(NULL));

  while( length-- )
  {
    *matriz=rand()%99+1;
    ++matriz;
  }
}

void imprimirArreglo(int* matriz, int n){
  for(int i=0;i<n;i++){
    for(int j=0;j<n;++j,++matriz){
      cout<<*matriz<<'\t';
    }
    cout<<'\n';
  }
}

int main(){

  int n;
  cin >> n;
  int* matriz = new int[n*n];
  generarArreglo(matriz, n*n);
  imprimirArreglo(matriz, n);
  delete[] matriz;

  system("pause");
  return 0;
}

Your code

int matriz[n][n];

is not valid in C++. The dimensions of an array must be constants, not variables. You'll have to declare it as a pointer, and allocate memory on the fly:

int *matriz;
matriz = calloc( n, n );

And you will have to modify all your functions, of course.

EDIT

To access via pointers, it's the same (I'm sure in C, throw me to the wolves if the same doesn't happen in C++):

int *matriz = calloc( n, n );

matriz[0][0] = *matriz;
matriz[0][1] = matriz[2];
matriz[1][0] = matriz[n] = matriz[n][0]

If instead of ugly and dirty C++ you used plain C , you could use variables to declare arrays (in C11).

In C , a arrayand a punteroare equivalent. If you declare a array[], the compiler allocates memory for the indicated size, and what you actually use is a pointer to that memory.

EDIT 2

Why do you use 2 fornested ? with what do you use

int *idx;
for( idx = matriz; idx < n * n; ++ idx ) {
 . . .
}

The arrayand memory blocks returned by calloc(), malloc()and the like are contiguous in memory . Simply, imagine that it is a array[]one-dimensional, but much longer.

EDIT 3

From your comments, I see you wanting to learn.

#include <iostream>
#include <stdlib.h>
#include <time.h>

void generarArreglo( int *matrix, int size ){
  srand( time( NULL ) );

  while( size -- )
    *matrix++ = rand( ) % 99 + 1;
}

void imprimirArreglo( int *matrix, int ancho, int size ) {
  int pos = 0;

  while( size-- ) {
    ::std::cout << "[" << *matrix++ << "]";
    if( ! ( ++pos % ancho ) )
      ::std::cout << ::std::endl;
  }

 ::std::cout << ::std::endl;
}

int main( ) {
  int *matriz;
  int n;

  ::std::cin >> n;
  matriz = (int *)calloc( n, n );

  generarArreglo( matriz, n * n );
  imprimirArreglo( matriz, n, n * n );

  system( "pause" );
  return 0;
}

Version 1.0. Patches are supported.

PS - For code like that, C / C++ are said to be write-only .

I propose that the array be declared in the form:

int mat[n][n];

Only as a good practice, because if it is declared dynamically, although this is done automatically, it is recommended that in the end the memory that was requested from the system be manually released, however, in this way, it is not necessary. The other thing I propose is that by passing the array as a parameter as a pointer + the dimensions, this makes it much more flexible when working with the array if we want to make subsequent changes to its dimensions.