Paso de arreglos y punteros como parámetros.

                   
Paso de Arreglos como Parametros

Para pasar arreglos como parámetros debemos recordar que con arreglos no existe el paso por valor como existía en las variables individuales, solo se puede pasar por referencia(dirección)lo que quiere decir que todas las modificaciones que se hagan dentro del arreglo afectaran también a la variable original
Para pasar un arreglo completo como parametro a un procedimiento a una función solo se manda el nombre del arreglo sin corchetes e indices, en el procedimiento o función que recibe solo se declara un arreglo del mismo tipo y se puede usar el mismo o diferente nombre del arreglo.
Entonces tenemos 2 maneras:
void func(int a[]);
void func(int a[5]); 

Ejemplo:
int ingreso(int );
void imprimir(int );

void main() {
      int n[100];
      ingreso(n[100]);
      imprimir(n[100]);
      system("pause");

}

int ingreso(int vect) {
      for (int i = 0; i < 5; i++) {
            cout << "Ingrese un numero: ";
            cin >> vect;
            return vect;
      }
}

void imprimir(int vect) {
      for (int i = 0; i < 5; i++) {
            cout << ingreso(vect) << "\n";
            (vect++);
      }
}

Paso de arreglos utilizando punteros

La manera de declarar la función es:
void func(int *a); 
Podemos acceder a los elementos de un modo alternativo usando un puntero de esta manera:
int *ptr;
 ptr = &mi_arreglo[0]; /* apuntamos nuestro apuntador al primer entero de nuestro arreglo */
ejemplo:
int mi_arreglo[] = {1,23,17,4,-5,100};
int *ptr;
int main(void)
{
 int i;
 ptr = &mi_arreglo[0]; /* apuntamos nuestro puntero
 al primer elemento del arreglo*/
 printf("\n\n");
 for (i = 0; i < 6; i++)
 {
 printf("mi_arreglo[%d] = %d ", i, mi_arreglo[i]); /*<-- A */
 printf("ptr + %d = %d\n",i, *(ptr + i)); /*<-- B */
 }
 return 0;
}

En C, el estándar establece que donde usemos &nombre_de_la_variable[0] podemos reemplazarle con nombre_de_la_variable, esto en el código de ejemplo lo que escribimos como:
ptr = &mi_arreglo[0];
podemos escribirlo como:
 ptr = mi_arreglo;
y obtenemos el mismo resultado.

Arreglos en Memoria Dinámica

Para utilizar un arreglo en memoria dinámica debemos declarar: arreglo = new char[filas]; de esta manera podemos reservar memoria para cada uno de sus espacios.

char * cadena_dinamica = NULL; // arreglo vacio.
 int cantidad = 0;
 //obtenemos un valor de cantidad capturado de consola
 cout<< "Por favor digite el tamaño del arreglo ";
 cin>>cantidad;

 // creamos el arreglo dinámico con el parametro capturado
 cadena_dinamica = new char[cantidad];


Paso de Matrices como Parametros

Para matrices, funciona de la misma forma que existía para arreglos, al momento de declarar la función es importante especificar el numero de columnas  ya que la función receptora debe conoce la estructura interna de la matriz, para poder para acceder a sus elementos, y esto solo es posible informándole de su tipo y dimensiones.

int matriz[100][100];
void main() {

      int n, n1;
     
      cout << "ingrese el tamaño de la fila = ";
      cin >> n;
      cout << "ingrese el tamaño de la columna = ";
      cin >> n1;
      for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; n++) {
                  cout << "ingrese el valor de [" << i+1 << "],[" << j+1 << "]  =";
                  cin >> matriz[i][j];
            }
      }
      for (int i = 0; i < n; i++) {
            for (int j = 0; j < n1; n++) {
                  //gotoxy(i + 5, 2 * j + 3);
                  cout << matriz[i][j];
            }
      }
}
func (int dias[2][12]) {...}

Matrices en memoria dinámica

Para utilizar matrices con memoria dinámica primero debemos reservar el espacio para el numero de filas como si fuera un vector mat = new int*[*dim]; después lo hacemos para cada una de sus columnas, para la lectura de datos utilizamos la estructura siguiente: (&(*(*(mat + i) + j))) o también (*(*(&mat) + i) + j)), y para la escritura (*(*(mat + i) + j))
void diagonal();
void ingreso(int **, int *);
void ingresomat(int **, int *);
void impresion(int **, int *);
int main() {
      diagonal();
      system("pause");
}

void diagonal() {
      int **mat, *dim;
      ingreso(mat, dim);

     
      system("pause");
}

void ingreso(int **mat, int *dim) {
      dim = new (int);
      cout << "ingrese dimension" << endl;
      scanf("%d", (&(*dim)));
      mat = new int*[*dim];
      for (int i = 0; i < *dim; i++) {
            *(mat+i) = new int[*dim];
      }
      ingresomat(mat, dim);
}

void ingresomat(int **mat, int *dim) {
      for (int i = 0; i < *dim; i++) {
            for (int j = 0; j < *dim; j++) {
                  scanf("%d", (&(*(*(mat + i) + j))));

            }
      }

      impresion(mat, dim);
}

void impresion(int **mat, int *dim) {
      for (int i = 0; i < *dim; i++) {
            for (int j = 0; j < *dim; j++) {
                  printf("%d", *(&(*(*(mat + i) + j))));
            }
            cout << endl;
      }
}


Programa que Multiplica 2 matrices en memoria dinamica

void multiplicacion();
void datosmat(int **,int *,int *);
void impresion(int **mat,int *fila, int *columna);
void encerar(int **mat,int *filas, int *columnas);
void multiplicar(int **mat1,int **mat2,int **mat3,int *filas,int *filas2, int *columnas2);

int main(){
      multiplicacion();
      return 0;
}

void multiplicacion(){
      int *filas=new (int),*columnas=new (int);
      cout<<"ingrese las dimensiones de la matriz 1"<<endl;
      cin>>*filas>>*columnas;
      int **mat1=new int*[*filas];
      for(int i=0;i<*filas;i++){
            *(mat1+i)=new int[*columnas];
      }
     
     
      int *filas2=new (int),*columnas2=new (int);
      cout<<"ingrese las dimensiones de la matriz 1"<<endl;
      cin>>*filas2>>*columnas2;
      int **mat2=new int*[*filas2];
      for(int i=0;i<*filas2;i++){
            *(mat2+i)=new int[*columnas2];
      }
     
      cout<<"ingrese datos de matriz 1"<<endl;
      datosmat(mat1,filas,columnas);
     
      cout<<"datos de la matriz 1:"<<endl;
      impresion(mat1,filas,columnas);
     
      cout<<"ingrese datos de la matriz 2"<<endl;
      datosmat(mat2,filas2,columnas2);
     
      cout<<"datos de la matriz 2:"<<endl;
      impresion(mat2,filas2,columnas2);              
     
      int **mat3=new int*[*filas];
      for(int i=0;i<*filas;i++){
            *(mat3+i)=new int[*columnas2];
      }
     
     
      cout<<"datos de la matriz 3"<<endl;
      encerar(mat3,filas,columnas2);
      cout<<endl<<endl;
      cout<<"la multiplicacion es:"<<endl;
      multiplicar(mat1,mat2,mat3,filas,filas2,columnas2);
     
}

void datosmat(int **mat,int *filas, int *columnas){
      for(int i=0;i<*filas;i++){
            for(int j=0;j<*columnas;j++){
                  //scanf("%d",&(*(*(mat+i)+j)));
                  scanf("%d",*(*(&mat)+i)+j);
            //    cin>>mat[i][j];
            }
      }
}

void impresion(int **mat,int *filas, int *columnas){
      for(int i=0;i<*filas;i++){
            for(int j=0;j<*columnas;j++){
                  printf("%d        ",*(*(mat+i)+j));
                  //printf("%d            ",*(*(mat)+i)+j);
            }
            cout<<endl;
      }
}

void encerar(int **mat,int *filas, int *columnas){
      for(int i=0;i<*filas;i++){
            for(int j=0;j<*columnas;j++){
                  *(*(mat+i)+j)=0;
            //    printf("%d",*(*(mat+i)+j));
            }
            cout<<endl;
      }
}

void multiplicar(int **mat1,int **mat2,int **mat3,int *filas,int *filas2, int *columnas2){
      for (int k = 0; k<*filas; k++) {
                        for (int f = 0; f<*columnas2; f++) {
                              for (int c = 0; c<*filas2; c++) {
                                    *(*(mat3+k)+f )= *(*(mat3+k)+f ) + (*(*(mat1+k)+f )       *     (*(*(mat2+k)+f )));
                              }
                              printf("%d  ",*(*(mat3+k)+f));
                        }
                        cout << endl;
                  }
}


Arreglos de punteros

Son vectores cuyos elementos son punteros, cada uno de estos puede apuntar a un tipo de dato especifico