28/05/2024
# Tags
#C++ #Programación

Arrays como parámetros en funciones

C ++ no permite pasar una matriz completa como un argumento a una función. Sin embargo, puedes pasar un puntero a una matriz especificando el nombre de la matriz sin un índice. Para pasar una matriz de una sola dimensión como argumento en una función, se debe declarar el parámetro formal en una de las siguientes tres formas y los tres métodos de declaración producirán resultados similares porque cada uno le dice al compilador que recibirá un puntero entero.

Método 1

Parámetro como puntero.

void MiFuncion(int *parametro) {
//código de la función
}

Método 2

Parámetro como un Array de tamaño fijo

void MiFuncion(int *parametro[10]) {
    //código de la función
}

Método 3

Parámetros como un Array sin tamaño

void MiFuncion(int *parametro[]) {
    //código de la función
}

Llamando a un función con un Array como parámetro

Los arrays en C++se pasan siempre a las funciones por referencia. El nombre de un array realmente es un puntero que contiene la dirección de memoria donde comienza el array, o lo que es lo mismo, la dirección de memoria del primer elemento. Cuando se pasa un array a una función, la función recibe la dirección de memoria donde se encuentra el primer elemento del array. Por lo tanto, la función trabaja sobre el array original.

Consecuencia de este hecho, es que cuando un Array se modifica en una función que lo ha recibido como parámetro, la estructura sufre cambios de forma permanente dentro del programa principal. Si esto no es lo que quieres, es importante que protejas al Arreglo al momento de definirlo, esto lo puedes hacer declarándolo como constante.

Llamada a un Array unidimensional

Cuando llamamos una función que recibe un Array como parámetro, debemos pasarle el Array sin los índices, es decir, solo debemos indicar el nombre del arreglo que se pasa.

Por ejemplo consideremos que hemos definido la siguiente función que recibe un arreglo de strings:

int MostrarArray(string OpcionMenu[]);

Para pasar el arreglo

string Menu[] = {«Archivo», «Edición», «Herramientas», «Salir»};

dentro de la función que lo llama lo haremos de la siguiente forma:

string Menu[] = {"Archivo", "Edición", "Herramientas", "Salir"};
MostrarArray(Menu); //Nota que solo pasamos el nombre del arreglo

a continuación te presento un primer ejemplo muy sencillo para que identifiques como utilizar los arreglos como parámetros en funciones.

Ejemplo 1

// eb80_ParamArray01.cpp
 // Este programa forma parte del tutorial de introducción al lenguaje C++
 // http://a.ehack.info/leguaje-c-introduccion/
 // Se ilustra el paso de Arrays como parámetros en funciones en C++
 // 2019, Por http://about.me/carlosgbr
 // Versión 1
 // Compilado en https://www.onlinegdb.com/online_c++_compiler
 include <iostream>
 include <string>
 using namespace std;
 int MostrarArray(string OpcionMenu[], int NumOpciones);
 int main()
 {
     int NumOpciones = 4;
     string Menu[] = {"Archivo", "Edición", "Herramientas", "Salir"};
     MostrarArray(Menu, NumOpciones);  return 0; } //Despliega las opciones que se reciben en el Arreglo int MostrarArray(string OpcionMenu[], int NumOpciones) { for (int i=0; i<NumOpciones; i++)  { cout << OpcionMenu[i] << endl; }  return 0; }

Comentarios al programa

El programa anterior, aunque simple, tiene algunos aspectos importantes que debes considerar.

int MostrarArray(string OpcionMenu[], int NumOpciones);

En esta línea definimos el prototipo de la función, puedes notar que no se utiliza el tamaño del Array, por lo que podemos recibir cualquier tamaño de arreglo. Esto no obliga a conocer el número de elementos que vamos a recibir, para evitar caídas del sistema por utilizar el valor incorrecto, para esto definimos el parámetro NumOpciones, para poder identificar el número de elementos que contiene el Arreglo. Pasar este dato es responsabilidad de quien llama a la función.

Otro punto importante que se debe señalar es que es frecuente omitir el nombre del parámetro que recibe el arreglo. De modo que algunos programadores pueden expresar la misma función del siguiente modo.

int MostrarArray(string [], int NumOpciones);

Observa que utilizamos una variable para determinar el tamaño del arreglo y los elementos que lo componen, así mismo este valor se pasa como parámetro en la función, de este modo evitamos desbordamientos de memoria y de lecturas en localidades de memoria que pueden ocasionar que nuestro programa se cuelgue.

int NumOpciones = 4;
     string Menu[] = {"Archivo", "Edición", "Herramientas", "Salir"};
     MostrarArray(Menu, NumOpciones); 

Sin embargo esta definición del número de elementos del Arreglo no sirve si recibiremos cualquier número de parámetros (eso es el objetivo definir un Array sin índices), por lo que podemos calcular en tiempo de ejecución el número de nuestro Arreglo con un cálculo muy simple.

int elementos = 0;
elementos = sizeof(Menu)/sizeof(*Menu);

De esta forma mantenemos la generalidad de nuestra función.

Finalmente se debe señalar que una función que recibe Arrays como parámetros no puede devolver un arreglo en return. Esto se entiende por lo expresado anteriormente: Los arreglos son modificados directamente en memoria por lo que no es útil ni necesario el valor de un Array devuelto en una función.

Sumando con Arrays

El caso anterior solo muestra información, sin embargo regularmente utilizaremos Arrays en funciones, para realizar cálculos. A continuación presento otro ejemplo para que tengas posibilidad de profundizar en el uso de los arreglos como parámetros de funciones.

// eb81_ParamArray02.cpp
 // Este programa forma parte del tutorial de introducción al lenguaje C++
 // http://a.ehack.info/leguaje-c-introduccion/
 // Se ilustra el paso de Arrays como parámetros en funciones en C++
 // Este programa realiza la suma de enteros utilizando arreglos
 // pasados arreglos funciones
 // 2019, Por http://about.me/carlosgbr
 // Versión 1
 // Compilado en https://www.onlinegdb.com/online_c++_compiler
 include
 using namespace std;
 void pedirDatos(int suma[], int max);
 int totalSuma(int suma[],int max);
 int main(){
  int max = 5;
  int suma[max];
  pedirDatos(suma,max);
  cout << "Suma total: " << totalSuma(suma, max) << endl;
  return 0;
 }
 void pedirDatos(int suma[],int max){
         cout << "Introduce " << max << " números enteros" << endl;  for(int i = 0; i < max; i++){   cin >> suma[i];
  }
 }
 int totalSuma(int Suma[],int max){
  int sumaTotal = 0;
  for(int i = 0; i < max; i++){
   sumaTotal += Suma[i];
  }
  return sumaTotal;
 }

Puedes notar que el procedimiento es el mismo, definimos el arreglo en el programa principal y se lo pasamos como parámetro a las funciones que manipularán el arreglo.

Finalmente presentamos un último ejemplo.

// eb81_ParamArray02.cpp
 // Este programa forma parte del tutorial de introducción al lenguaje C++
 // http://a.ehack.info/leguaje-c-introduccion/
 // Se ilustra el paso de Arrays como parámetros en funciones en C++
 // Este programa realiza la suma de enteros utilizando arreglos
 // pasados arreglos funciones
 // 2019, Por http://about.me/carlosgbr
 // Versión 1
 // Compilado en https://www.onlinegdb.com/online_c++_compiler
 include
 using namespace std;
 void pedirDatos(int suma[], int max);
 int totalSuma(int suma[],int max);
 int main(){
  int max = 5;
  int suma[max];
  pedirDatos(suma,max);
  cout << "Suma total: " << totalSuma(suma, max) << endl;
  return 0;
 }
 void pedirDatos(int suma[],int max){
         cout << "Introduce " << max << " números enteros" << endl;  for(int i = 0; i < max; i++){   cin >> suma[i];
  }
 }
 int totalSuma(int Suma[],int max){
  int sumaTotal = 0;
  for(int i = 0; i < max; i++){
   sumaTotal += Suma[i];
  }
  return sumaTotal;
 }

En este ejemplo puedes observar muchos de los conceptos en funcionamiento que se han revisado en este tutorial. la parte correspondiente a los parámetros de Arreglos en funciones, operan con ellos, no sobre ellos (el arreglo original se mantiene intacto)

Parámetros por referencia

Se ha mencionado que los arreglos se pasan por referencia dentro de una función, esto quiere decir que si modificamos una función dentro de una función y ésta realiza un cambio en el arreglo que se recibe, los cambios sobre el arreglo son permanentes, el siguiente ejemplo ilustra esta situación.

// eb82_ParamArray03.cpp
 // Este programa forma parte del tutorial de introducción al lenguaje C++
 // http://a.ehack.info/leguaje-c-introduccion/
 // Se ilustra el paso de Arrays como parámetros en funciones en C++
 // Este programa ilustra como se modifica un arreglo dentro de una función
 // y su afectaciòn en la función principal
 // 2019, Por http://about.me/carlosgbr
 // Versión 1
 // Compilado en https://www.onlinegdb.com/online_c++_compiler
 include
 using namespace std;
 int CapturaAlumnos(string [], int NumAlumnos);
 int main()
 {
     int NumAlumnos = 0;
 cout << "Escribe el número de alumnos a registrar: "; cin >> NumAlumnos; string alumnos[NumAlumnos]; CapturaAlumnos(alumnos, NumAlumnos); for (int i=0; i<NumAlumnos; i++)     {         cout << "Alumno " << i+1 << " : "<< alumnos[i] << endl;     }  return 0; } int CapturaAlumnos(string NombreAlumno[], int NumAlumnos) { for (int i=0; i> NombreAlumno[i]; } return 0; }

Matrices como parámetros de funciones

Pasar matrices como variables en una función es similar a los Arreglos unidimensionales.

Recuerda que un Array de 2 o más términos se denomina comúnmente como Matriz

// eb83_ParamArray04.cpp
 // Este programa forma parte del tutorial de introducción al lenguaje C++
 // http://a.ehack.info/leguaje-c-introduccion/
 // Se ilustra el paso de Arrays Multidimensionales como parámetros
 // en funciones en C++
 // 2019, Por http://about.me/carlosgbr
 // Versión 1
 // Compilado en https://www.onlinegdb.com/online_c++_compiler
 include
 using namespace std;
 void ImprimeMatriz(int matriz, int fila, int col) {     for (int i=0;icol+j]<<" ";
         }
         cout<<endl;
     }
 }
 int main()
 {
     int matriz[4][5] = {{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5},{1,2,3,4,5}};
     int m1[5][3] = {{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15}};
     ImprimeMatriz((int *)matriz, 4, 5);
     ImprimeMatriz((int *)m1,5,3);
 return 0; }

Puedes notar la semejanza con los Arreglos unidimensionales, probablemente la única parte que requiere mención especial es la que se refiere al nombre de las variables, en los parámetros, en donde el nombre del primer parámetro puede ser opcional, pero los siguientes son obligatorios.

Otros recursos

Te sugiero revises otros programas con arreglos como parámetros en funciones. A continuación te facilito algunos ejemplos que a mi consideración vale la pena revises.

Código Fuente

Licencia de Creative Commons
Arrays como parámetros en funciones en C++ by Roberto C. González is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 4.0 Internacional License.
Arrays como parámetros en funciones

Recursión en C++

Leave a comment

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *