Mirando las fotos de los comentarios en la primera respuesta
p es un puntero que contiene el espacio de memoria donde está contenido el primer valor de la matriz. si imprime p verá un número como 1606416192, este espacio de memoria contiene el primer valor de la matriz, en su caso el valor 1. Puede acceder a los otros espacios de memoria con p [1], p [2] . Además, puede usar * p para acceder al primer espacio de memoria: por ejemplo
printf (“% d”, * p + 1);
accederá al segundo espacio de memoria (el segundo valor):
* p es lo mismo que p [0]
* (p + 1) es lo mismo que p [1]
* (p + 2) es lo mismo que p [2]
- ¿Cómo se ordenan 10 números en orden creciente?
- ¿Existe un límite superior para la capacidad de comprensión de un individuo? Si es así, ¿qué se debe hacer para mejorarlo?
- ¿Cómo planificarías un campamento de algoritmos y estructuras de datos de un mes?
- ¿Qué es el retroceso en algoritmos?
- Deje G (V, E) ser un gráfico conectado, no dirigido, dar un algoritmo O (| V | + | E |) para calcular una ruta en G que atraviesa cada borde en E exactamente una vez en cada dirección?
la línea
suma + = * p + * q;
cambiar a
suma + = p [i] + q [i];
o
suma + = * (p + i) + * (q + i);
o
suma + = * (p ++) + * (q ++)
No entiendo por qué la siguiente línea es sum ++;
cuando declaras un puntero int * p es una referencia a un espacio de memoria
pero cuando usa * p es un operador de deferencia (en este caso en una suma), está extrayendo la información de este espacio de memoria.
Lea esto si necesita más ayuda con el operador de deferencia: ¿Qué significa “desreferenciar” un puntero?
Un ejemplo en código:
#include
int main (int argc, const char * argv []) {
int arr1 [5] = {1, 12, 3, 4, 7};
int arr2 [5] = {10, 11, 2, 8, 5};
int * p, * q, * p_tmp, * q_tmp;
int nElement = 0, sum = 0, sum2 = 0, sum3 = 0;
p = arr1;
q = arr2;
p_tmp = arr1;
q_tmp = arr2;
para (nElement = 0; nElement <5; nElement ++) {
suma + = * (p + nElement) + * (q + nElement);
}
para (nElement = 0; nElement <5; nElement ++) {
sum2 + = p [nElement] + q [nElement];
}
printf (“La suma es:% d% d \ n”, sum, sum2);
printf (“Tamaño de int:% d bytes \ n”, sizeof (int));
printf (“Dirección de memoria \ t \ t | Dirección de memoria \ n”);
printf (“de p_tmp \ t valor | de q_tmp \ t valor \ n”);
para (nElement = 0; nElement <5; nElement ++) {
printf (“% d \ t \ t% 2d |% d \ t \ t% 2d \ n”, p_tmp, * p_tmp, q_tmp, * q_tmp);
sum3 + = * (p_tmp ++) + * (q_tmp ++); / ** Mueve el puntero al siguiente bloque de memoria, 4 bytes de diferencia. ** /
}
printf (“Ahora el puntero apunta a una dirección de memoria fuera de la matriz y contiene basura \ n”);
printf (“Memoria% d valor% d memoria% d valor% d \ n”, p_tmp, * p_tmp, q_tmp, * q_tmp);
printf (“Mueve el puntero a la última dirección de memoria \ n”);
printf (“% d% d \ n”, * (- p_tmp), * (- q_tmp));
printf (“La suma es:% d% d% d”, sum, sum2, sum3);
printf (“\ n”);
devuelve 0;
}
¡Mis mejores deseos!
