Los punteros se utilizan para almacenar direcciones de arrays asignadas dinámicamente y para arrays que se pasan como argumentos a funciones. En otros contextos, las arrays y el puntero son dos cosas diferentes, consulte los siguientes programas para justificar esta afirmación.
Comportamiento del operador sizeof
C++
// 1st program to show that array and pointers are different
#include <iostream>
using namespace std;
int main()
{
int arr[] = { 10, 20, 30, 40, 50, 60 };
int* ptr = arr;
// sizof(int) * (number of element in arr[]) is printed
cout << "Size of arr[] " << sizeof(arr) << "\n";
// sizeof a pointer is printed which is same for all
// type of pointers (char *, void *, etc)
cout << "Size of ptr " << sizeof(ptr);
return 0;
}
C
// 1st program to show that array and pointers are different
#include <stdio.h>
int main()
{
int arr[] = { 10, 20, 30, 40, 50, 60 };
int* ptr = arr;
// sizof(int) * (number of element in arr[]) is printed
printf("Size of arr[] %ld\n", sizeof(arr));
// sizeof a pointer is printed which is same for all
// type of pointers (char *, void *, etc)
printf("Size of ptr %ld", sizeof(ptr));
return 0;
}
Size of arr[] 24 Size of ptr 8
No se permite asignar ninguna dirección a una variable de array.
C++
// IInd program to show that array
// and pointers are different
#include <iostream>
using namespace std;
int main()
{
int arr[] = {10, 20}, x = 10;
int *ptr = &x; // This is fine
arr = &x; // Compiler Error
return 0;
}
// This code is contributed by Shubhamsingh10
C
// IInd program to show that array and pointers are different
#include <stdio.h>
int main()
{
int arr[] = {10, 20}, x = 10;
int *ptr = &x; // This is fine
arr = &x; // Compiler Error
return 0;
}
Producción:
Compiler Error: incompatible types when assigning to
type 'int[2]' from type 'int *'
Consulte la publicación anterior sobre este tema para ver más diferencias.
Aunque la array y el puntero son cosas diferentes, las siguientes propiedades de la array los hacen parecer similares.
- El nombre de la array proporciona la dirección del primer elemento de la array.
Considere el siguiente programa, por ejemplo.
C++
// 1st program to show that array and pointers are different
#include <iostream>
using namespace std;
int main()
{
int arr[] = { 10, 20, 30, 40, 50, 60 };
// Assigns address of array to ptr
int* ptr = arr;
cout << "Value of first element is " << *ptr;
return 0;
}
C
#include <stdio.h>
int main()
{
int arr[] = { 10, 20, 30, 40, 50, 60 };
// Assigns address of array to ptr
int* ptr = arr;
printf("Value of first element is %d", *ptr);
return 0;
}
Value of first element is 10
Se accede a los miembros de la array mediante aritmética de punteros.
El compilador usa aritmética de punteros para acceder al elemento de la array. Por ejemplo, el compilador trata una expresión como “arr[i]” como *(arr + i). Es por eso que las expresiones como *(arr + i) funcionan para el arreglo arr, y las expresiones como ptr[i] también funcionan para el puntero ptr.
C++
#include <iostream>
using namespace std;
int main()
{
int arr[] = { 10, 20, 30, 40, 50, 60 };
int* ptr = arr;
cout << "arr[2] = " << arr[2] << "\n";
cout << "*(arr + 2) = " << *(arr + 2) << "\n";
cout << "ptr[2] = " << ptr[2] << "\n";
cout << "*(ptr + 2) = " << *(ptr + 2) << "\n";
return 0;
}
C
#include <stdio.h>
int main()
{
int arr[] = {10, 20, 30, 40, 50, 60};
int *ptr = arr;
printf("arr[2] = %d\n", arr[2]);
printf("*(arr + 2) = %d\n", *(arr + 2));
printf("ptr[2] = %d\n", ptr[2]);
printf("*(ptr + 2) = %d\n", *(ptr + 2));
return 0;
}
arr[2] = 30 *(arr + 2) = 30 ptr[2] = 30 *(ptr + 2) = 30
Los parámetros de array siempre se pasan como punteros, incluso cuando usamos corchetes.
C++
#include <bits/stdc++.h>
using namespace std;
int fun(int ptr[])
{
int x = 10;
// Size of a pointer is printed
cout << "sizeof(ptr) = "
<< (int)sizeof(*ptr)
<< endl;
// This allowed because ptr is a
// pointer, not array
ptr = &x;
cout <<"*ptr = " << *ptr;
return 0;
}
// Driver code
int main()
{
int arr[] = { 10, 20, 30, 40, 50, 60 };
// Size of a array is printed
cout << "sizeof(arr) = "
<< (int)sizeof(arr)
<< endl;
fun(arr);
return 0;
}
// This code is contributed by shivanisinghss2110
C
#include <stdio.h>
int fun(int ptr[])
{
int x = 10;
// size of a pointer is printed
printf("sizeof(ptr) = %d\n", (int)sizeof(*ptr));
// This allowed because ptr is a pointer, not array
ptr = &x;
printf("*ptr = %d ", *ptr);
return 0;
}
// Driver code
int main()
{
int arr[] = { 10, 20, 30, 40, 50, 60 };
// size of a array is printed
printf("sizeof(arr) = %d\n", (int)sizeof(arr));
fun(arr);
return 0;
}
sizeof(arr) = 24 sizeof(ptr) = 4 *ptr = 10
Veamos las diferencias en forma tabular -:
| Puntero | formación | |
| 1. |
Se declara como -: *var_nombre; |
Se declara como -: tipo_datos var_name[tamaño]; |
| 2. | Se utiliza para almacenar la dirección de diferentes variables del mismo tipo de datos. | Se utiliza para almacenar la variable múltiple del mismo tipo de datos. |
| 3. | Podemos generar un puntero a la array. | Podemos generar una array de puntero |
| 4. | Está diseñado para almacenar la dirección de la variable | Está diseñado para almacenar el valor de la variable. |
| 5. | Una variable de puntero puede almacenar la dirección de una sola variable a la vez. | Una array puede almacenar la cantidad de elementos del mismo tamaño que el tamaño de la variable de la array. |
Consulte Pointer vs Array en C para obtener más detalles.
Este artículo es una contribución de Abhay Rathi . Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
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