Una array completa no se puede pasar como argumento a una función en C++. Sin embargo, puede pasar un puntero a una array sin índice especificando el nombre de la array.
En C, cuando pasamos una array a una función, digamos fun(), fun() siempre la trata como un puntero. El siguiente ejemplo demuestra lo mismo.
C++
// CPP Program to demonstrate passing
// an array to a function is always treated
// as a pointer
#include <iostream>
using namespace std;
// Note that arr[] for fun is
// just a pointer even if square
// brackets are used
void fun(int arr[]) // SAME AS void fun(int *arr)
{
unsigned int n = sizeof(arr) / sizeof(arr[0]);
cout << "\nArray size inside fun() is " << n;
}
// Driver Code
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
unsigned int n = sizeof(arr) / sizeof(arr[0]);
cout << "Array size inside main() is " << n;
fun(arr);
return 0;
}
C
#include <stdio.h>
#include <stdlib.h>
// Note that arr[] for fun is just a pointer even if square
// brackets are used
void fun(int arr[]) // SAME AS void fun(int *arr)
{
unsigned int n = sizeof(arr)/sizeof(arr[0]);
printf("\nArray size inside fun() is %d", n);
}
// Driver program
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
unsigned int n = sizeof(arr)/sizeof(arr[0]);
printf("Array size inside main() is %d", n);
fun(arr);
return 0;
}
Producción
Array size inside main() is 8 Array size inside fun() is 1
Por lo tanto, en C, debemos pasar el tamaño de la array como parámetro. Es posible que el tamaño no sea necesario solo en el caso de arrays de caracteres terminadas en ‘\ 0’, el tamaño se puede determinar comprobando el final del carácter de string.
El siguiente es un ejemplo simple para mostrar cómo se pasan típicamente las arrays en C:
C++
#include <iostream>
using namespace std;
void fun(int *arr, unsigned int n)
{
int i;
for (i = 0; i < n; i++)
cout <<" "<< arr[i];
}
// Driver program
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
unsigned int n = sizeof(arr)/sizeof(arr[0]);
fun(arr, n);
return 0;
}
C
#include <stdio.h>
void fun(int *arr, unsigned int n)
{
int i;
for (i=0; i<n; i++)
printf("%d ", arr[i]);
}
// Driver program
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
unsigned int n = sizeof(arr)/sizeof(arr[0]);
fun(arr, n);
return 0;
}
Producción
1 2 3 4 5 6 7 8
Ejercicio: Prediga la salida de los siguientes programas en C:
Programa 1:
C++
// Program 1
#include <iostream>
using namespace std;
void fun(int arr[], unsigned int n)
{
int i;
for (i = 0; i < n; i++)
cout << arr[i] << " ";
}
// Driver program
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
unsigned int n = sizeof(arr) / sizeof(arr[0]);
fun(arr, n);
return 0;
}
C
#include <stdio.h>
void fun(int arr[], unsigned int n)
{
int i;
for (i=0; i<n; i++)
printf("%d ", arr[i]);
}
// Driver program
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
unsigned int n = sizeof(arr)/sizeof(arr[0]);
fun(arr, n);
return 0;
}
Producción
1 2 3 4 5 6 7 8
Programa 2:
C++
// Program 2
#include <iostream>
using namespace std;
void fun(int* arr)
{
int i;
//Consider the size of pointer as 8 bytes
unsigned int n = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < n; i++)
cout << " " << arr[i];
}
// Driver program
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
fun(arr);
return 0;
}
C
#include <stdio.h>
void fun(int *arr)
{
int i;
unsigned int n = sizeof(arr)/sizeof(arr[0]);
for (i=0; i<n; i++)
printf("%d ", arr[i]);
}
// Driver program
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
fun(arr);
return 0;
}
Producción
1 2
De acuerdo con el procesador, el tamaño del puntero cambia para una computadora de 32 bits, asigna 4 bytes al puntero y luego la salida se convierte en 1.
Programa 3:
C++
// Program 3
#include <iostream>
#include <string.h>
using namespace std;
void fun(char* arr)
{
int i;
unsigned int n = strlen(arr);
cout << "n = " << n << endl;
for (i = 0; i < n; i++)
cout << arr[i] << " ";
}
// Driver program
int main()
{
char arr[] = "geeksquiz";
fun(arr);
return 0;
}
C
#include <stdio.h>
#include <string.h>
void fun(char *arr)
{
int i;
unsigned int n = strlen(arr);
printf("n = %d\n", n);
for (i=0; i<n; i++)
printf("%c ", arr[i]);
}
// Driver program
int main()
{
char arr[] = "geeksquiz";
fun(arr);
return 0;
}
Producción
n = 9 g e e k s q u i z
Programa 4:
C++
// Program 4
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
void fun(char* arr)
{
int i;
unsigned int n = strlen(arr);
cout << "n = " << n << "\n";
for (i = 0; i < n; i++)
cout << " " << arr[i];
}
// Driver program
int main()
{
char arr[]
= { 'g', 'e', 'e', 'k', 's', 'q', 'u', 'i', 'z' };
fun(arr);
return 0;
}
C
#include <stdio.h>
#include <string.h>
void fun(char *arr)
{
int i;
unsigned int n = strlen(arr);
printf("n = %d\n", n);
for (i=0; i<n; i++)
printf("%c ", arr[i]);
}
// Driver program
int main()
{
char arr[] = {'g', 'e', 'e', 'k', 's', 'q', 'u', 'i', 'z'};
fun(arr);
return 0;
}
Producción
n = 11 g e e k s q u i z
NOTA: La array de caracteres en el programa anterior no termina en ‘\0’. (Ver esto para más detalles)
Ahora, estos fueron algunos de los enfoques comunes que usamos, pero ¿sabe que hay una mejor manera de hacer lo mismo? Para esto, primero debemos analizar los inconvenientes de todos los métodos sugeridos anteriormente:
Inconvenientes:
- Un inconveniente importante del método anterior es que el compilador no tiene idea de lo que está pasando. Lo que quiero decir aquí es que para el compilador solo estamos pasando un int* y sabemos que apunta a la array, pero el compilador no lo sabe.
- Para verificar mi declaración, puede llamar a for-each loop en su array. Seguramente obtendrá un error que dice que no se encontró una función de inicio y finalización invocable.
Esto se debe a que la array que pasa es como pasar un puntero entero y en sí misma no tiene información sobre la array subyacente, por lo que no se proporciona un iterador.
Enfoque de plantilla (referencia a array):
Este método conserva toda la información sobre la array subyacente. Este método se basa principalmente en la referencia a una array, pero usarlo con plantillas optimiza nuestro método. La dependencia de la plantilla en realidad calcula la longitud de la array automáticamente en el momento de la llamada a la función para que pueda usarse para crear una referencia porque una referencia a una array debe conocer el tamaño de la array.
Aquí Plantilla se utiliza para la deducción de argumentos de plantilla.
C++
// CPP Program to demonstrate template approach
#include <iostream>
using namespace std;
template <size_t N> void print(int (&a)[N])
{
for (int e : a) {
cout << e << endl;
}
}
// Driver Code
int main()
{
int a[]{ 1, 2, 3, 4, 5 };
print(a);
}
1 2 3 4 5
Aquí puede ver por qué necesitamos la deducción de argumentos de plantilla. Para que una base cree una referencia a una array para que podamos tomar una array como parámetro.
Artículos relacionados:
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado aquí.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA