Aritmética de punteros

Clase 13 de 37 • Curso de Introducción a C 2019

Lautaro Cabral

student•

Notaron que la dirección de A es: 0x7fffdd626708 Mientras que la de B es: 0x7fffdd62670c

Entonces la "distancia" entre direcciones de memoria es sólo 4, como dijo el profe en la clase anterior un int ocupa 4 bytes, es decir 4 direcciones de memoria

Entonces pienso que A ocupa las direcciones: 0x7fffdd626708 0x7fffdd626709 0x7fffdd62670a 0x7fffdd62670b (Recordamos notación hexadecimal)

Y que inmediatamente después B ocupa las siguientes direcciones: 0x7fffdd62670c 0x7fffdd62670d 0x7fffdd62670e 0x7fffdd62670f

Entonces podría suponer que si hubiera declarado una variable int C, luego de declarar A y B, C ocupariá las siguientes direcciones: 0x7fffdd626710 0x7fffdd626711 0x7fffdd626712 0x7fffdd626713

QUE INTERESANTE

Stiven Andres Arevalo

student•

Bastante interesante tu observación no lo habría notado Gracias

Lautaro Cabral

student•

David Barreto

student•

Toda esta clase de aritmética de punteros me hizo recordar cuando aprendí a programar microcontroladores PIC, el famoso PIC16F877, tuve que aprender a como manejar esa memoria del PIC, las paginas de la memoria, todo con lenguaje ensamblador. Gracias a esa lógica he podido programar casi cualquier cosa que me den.

Stiven Andres Arevalo

student•

Muy duro programar con lenguaje ensamblador. Pero al menos tienes las bases para saber manejar la memoria lo que representa una ventaja para programar con C y cualquier otro lenguaje

Eduardo Sebastián Sandoval Jiménez

student•

Efectivamente una vez que aprendes la lógica es cuestión de adaptarte al lenguaje de programación!! Gracias por el aporte crack!!

Carlos Nassif Trejo Garcia

student•

Para lo que no les esta funcionando, en vez de incrementar, intente disminuir el puntero. A mi me funciono con el siguiente codigo:

#include &lt;stdio.h&gt;

int main(int argc, char const *argv[]) {
  int * pi;
  int a = 5;
  int b = 1;

  pi = &amp;a;
  printf(&quot;Antes a = %d, &amp;a = %p, b = %d, &amp;b = %p, pi = %p\n&quot;, a, &amp;a, b, &amp;b, pi);
  pi--;
  *pi = 10;
  printf(&quot;Despues a = %d, &amp;a = %p, b = %d, &amp;b = %p, pi = %p\n&quot;, a, &amp;a, b, &amp;b, pi);
  return 0;
}

Francisco Nuñez

student•

conmigo funciono igual, veo que en mi caso la dirección de memoria se asigno primero a la variable b pero no tengo idea de porque.

David Barreto

student•

No te preocupes eso es tarea del SO

Cristian Rosales Hernandez

student•

Como copiar y pegar en Vim .

Jeyson David Vargas Crespo

student•

Hola, sobre la linea que quieres copiar presionas dos veces "yy" y para pegar vas a donde quieres pegar y presionas "p" y listo.

David Barreto

student•

Buen aporte!

Saúl Alejandro Tapia Loya

student•

Algo interesante que mencionar es que el "++" no suma uno, lo que hace es mover algo a su próxima posición posible, por eso se salta de 4 en 4 en punteros de enteros, y por eso no puede utilizarse en números flotantes.

Victor Muchica Farfan

student•

Me funciono con pi - -

Resultado

Dilan Santiago Ariza Cañon

student•

A mi me paso lo mismo y agradezco tu ayuda, que sistema operativo tienes? yo cuento actualmente con win10

Victor Muchica Farfan

student•

Lo hice en un Windows10 64bits

Agustin Isaias Salinas Quinteros

student•

#include &lt;stdio.h&gt;// directiva del precompilador  libreria entrada y salida
int main()//funcion invocada cuando utilize el programa
{
  int n = 5; // Creamos una variable Tipo entero que Almacena un Valor de &quot;5&quot;
  int * pi = &amp;n; // creamos un Puntero a entero que tendra como valor la DIRECCION de la variable n 
  char cac= 'A'; // creamos variable de tipo char que almacenara CARACTERES
  char * pc = &amp;cac; // creamos un PUNTERO char que almacenara el contenido de la variable cac

  printf(&quot;Antes pi = %p y pc = %p\n&quot;, pi,pc);// muestra el antes de la incrementacion llamando a nuestros punteros de referencias
  pi++; //incrementamos nuestro PUNTERO entero
  pc++; // incrementamos nuestro PUNTERO Caracter
  printf(&quot;Despues pi = %p y pc = %p\n&quot;, pi,pc); //muestra el despues de la incrementacion llamando a nuestros punteros de referencias
}```

Dilan Santiago Ariza Cañon

student•

Código de inc_pointer con comentarios específicos para la comunidad :D

#include <stdio.h>

//funcion principal
int main(){

    //definimos la variable de tipo entero n con el dato numerico 5
    int n = 5;

    //definimos el puntero pi con la direccion de n
    int * pi = &n;
    
    //definimos la variable de tipo char c con el dato 'A'
    char c = 'A';
    
    //Definimos el puntero pc con la direccion de la variable c
    char * pc = &c;
    
    //imprimimos los datos originales recien creados
    printf("Antes pi = %p y pc = %p\n", pi, pc);
    
    //asignamos a pi un incremento en su dato para la direccion
    pi++;
    
    //asignamos a pi un incremento en su dato para la direccion
    pc++;

    //imprimimos los datos despues del incremento
    printf("despues del incrementeo pi = %p y pc = %p\n", pi, pc);
}

José Ignacio

student•

Compañer@s tengo la siguiente inquietud / Deducción del resultado que se ah generado en mi PC que por cierto difiere del resultado del ejercicio expuesto por el profesor y que muchos tenemos dudas...

<int main()
{
    int *pi;
    int a= 5;
    int b= 1;

    pi = &a;
    printf("Antes   a = %d, &a = %p, b = %d, &b = %p, pi = %p \n", a, &a, b, &b, pi);
    pi++;
   // *pi = 10;
    printf("Despues a = %d, &a = %p, b = %d, &b = %p, pi = %p \n", a, &a, b, &b, pi);

    return 0;
}>

<<**Resultado:**
Antes   a = 5, &a = 000000000061FE14, b = 1, &b = 000000000061FE10, pi = 000000000061FE14
Después a = 5, &a = 000000000061FE14, b = 1, &b = 000000000061FE10, pi = 000000000000000A
>

Inicialmente se aplica el incremento pi++ que incrementaría en 4 por ser entero y de hecho funciona, pero al asignarle el valor de 10 a *pi se descarta el incremento y se aplica la segunda asignación (*pi=10) la cual no se está generando una asignación a la coordenada a otra variable si no que se le está diciendo que su nueva posición reservada es 10 y que quizá corresponda a pi = 000000000000000A..

No sé si esto sea valido o sencillamente funciona diferente que al ejercicio expuesto por el profesor ya que los estoy ejecutando desde CodeBlocks en WIN1064bits

Adrian Turk

student•

Hola, el tema es que en la línea del printf del después, no estás pasando el puntero a la variable pi, estas pasando el valor de esa variable (te falto un &pi en la última línea), el cual estableciste con *pi=10; Lo que si le estas diciendo a printf es que pasarias un puntero, por eso te lo muestra con notación hexadecimal

Ivan E. Batista-Ochoa

student•

Hola, jivpacheco

Efectivamente, el puntero está apuntando a otra dirección. No obstante, tienes tu código comentado esta parte: // *pi = 10;. Por lo tanto, no se va a asignar el valor a la variable a la que está apuntando este puntero y la variable b tendrá el mismo valor de 1, es decir, a esta variable no se le va a reasignar el valor de 10.

Por otro lado, cuando imprimes pi estás imprimiendo una dirección de memoria, porque un apuntador guarda una dirección de memoria. En este caso, la dirección de memoria debería ser la misma que la dirección de memoria de la variable b.

He copiado tu código y este es el resultado que he obtenido:

#include<stdio.h>

int main()
{
	int *pi;
	int a= 5;
	int b= 1;

	pi = &a;
	printf("Antes a = %d, &a = %p, b = %d, &b = %p, pi = %p \n", a, &a, b, &b, pi);
	pi++;
	// *pi = 10;
	printf("Despues a = %d, &a = %p, b = %d, &b = %p, pi = %p \n", a, &a, b, &b, pi);

	return 0;
}


> RESULTADO EN CONSOLA

Antes a = 5, &a = 0x7ffc4af849d0, b = 1, &b = 0x7ffc4af849d4, pi = 0x7ffc4af849d0 

Después a = 5, &a = 0x7ffc4af849d0, b = 1, &b = 0x7ffc4af849d4, pi = 0x7ffc4af849d4

Aunque, para ser sincero, no sé porque cuando ejecutas en consola e imprime lo que está guardado en pi no te arroja la misma dirección de la variable b.

Si has encontrado la respuesta sería genial que la compartieras.

Oscar Jaramillo

student•

Muy interesante

Bento Cussei

student•

Muy buena clase!! Verdad que es bueno empezar desde los cimientos!

Nelson Allauca

student•

En mi caso no se superpone la posición de memoria.

Eso me hace pensar que el kernel de mi linux o el compidor de C que uso no lo permite, o el tamaño de memoria que tiene mi laptop... bueno si alguien sabe..

Guillermo Granado Garcia

student•

He realizado el ejemplo de wrong_pointer y mi puntero no apunta a la memoria de la variable b al incrementarlo. Sabes por que puede ser? Estoy usando clang sobre MacOS Te comparto el ejemplo que he realizado y el resultado

#include <stdio.h>

int main() {
    int * pi;
    int a = 5;
    int b = 1;

    pi = &a;
	printf( "Antes\n\t a = %d, &a = %p, b = %d, &b = %p, p = %p\n", a, &a, b, &b, pi );
	pi++;
	*pi = 10;
	printf( "Despues\n\t a = %d, &a = %p, b = %d, &b = %p, p = %p\n", a, &a, b, &b, pi );

    return 0;
}

Y el resultado es el siguiente:

Antes
         a = 5, &a = 0x7ffee93a376c, b = 1, &b = 0x7ffee93a3768, p = 0x7ffee93a376c
Despues
         a = 5, &a = 0x7ffee93a376c, b = 1, &b = 0x7ffee93a3768, p = 0x7ffe0000000a

David Felipe Bohórquez

student•

Tal vez tiene algo que ver con la manera en la que se maneja la memoria en Ubuntu. Yo uso Fedora y me dió igual que a tí, sin embargo en una maquina virtual con Ubuntu probé el mismo código y si se pisó la dirección de memoria de la variable b.

David Felipe Bohórquez

student•

![](

Youssef Abarca

student•

En mi caso tuvo que ser "pi--", ya que b ocupada una posición de memoria antes que a.

Irvin Vallejo

student•

int x = 0;
printf(&quot;%p\n&quot;, &amp;x); // Usa &amp; para obtener la dirección de una variable.
// (%p se sustituye por un puntero)
// =&gt; Muestra alguna dirección de memoria;

// Los tipos de puntero terminan con * en su declaración
int* px; // px es un puntero a un 'int'
px = &amp;x; // Almacena la dirección de x en px
printf(&quot;%p\n&quot;, px); // =&gt; Muestra alguna dirección de memoria

// Para obtener el valor de la dirección a la que apunta un puntero, pon
// * delante para desreferenciarle. 
printf(&quot;%d\n&quot;, *px); // =&gt; Muestra 0, el valor de x y de la dirección a la
                     //    que apunta px

// También puedes cambiar el valor al que está apuntando el puntero.
// Tenemos que meter la desreferencia entre paréntesis porque ++ tiene
// prioridad frente a *.
(*px)++; // Incrementa el valor al que apunta px en 1
printf(&quot;%d\n&quot;, *px); // =&gt; Muestra 1
printf(&quot;%d\n&quot;, x); // =&gt; Muestra 1```

Daniel Alejandro Romero

student•

Quisa este imaginado cosas muy extrañas, pero, si yo declaro una variable y luego le aplico una operación aritmética par moverla ¿Existe la posibilidad de entrar a un espacio en la memoria que por métodos tradicionales me pida contraseña la computadora para acceder a la información?

David Ramos Solís

student•

Probando el código idéntico (lo copié de la sección de Enlaces del Profesor) y usando Xcode en Mac, el resultado no es igual. El apuntador pi no avanza al siguiente punto (de a a b) y el resultado no es el mismo.

Alguien sabe que ocurre? será algo de la arquitectura de Mac?

Adrian Campos

student•

¿Que sucede en el caso de decremento de punteros?

Ivan E. Batista-Ochoa

student•

Por acá te comparto algunos recursos:

Pointer Arithmetic in C/C++
Pointer Arithmetic in C
Pointer Arithmetics in C with Examples

Dilan Santiago Ariza Cañon

student•

Este tipo de operaciones con direcciones de punteros cambian con el sistema operativo? He visto que algunos de mis compañeros en los "aportes" han tenido problemas con el programa y lo asignan para wrong_pointer.c con pi-- como lo muestro en el siguiente bloque de código

#include <stdio.h>

int main(){
    int * pi;
    int a = 5;
    int b = 1;

    pi = &a;
    printf("Antes a = %d, &a = %p, b = %d, &b = %p, pi = %p\n", a, &a, b, &b, pi);
    pi--;
    * pi = 10;
 
    printf("despues a = %d, &a = %p, b = %d, &b = %p, pi = %p\n", a, &a, b, &b, pi);

}

Sera el SO?

Marlon Iván De León Pérez

student•

En este programa lo que haces es asignar la dirección de memoria a

pi cuando haces el decremento pi-- dejas de apuntar a la dirección de memoria de la variable a el error del que hablas es debido a eso.

Respondiendo al sí las operaciones con punteros cambian dependiendo del sistema operativo, te diré que en mi experiencia esto no pasa, he probado con windows, mac y linux(con distros basadas en debian y en arch).

Julian Bustamante Cadavid

student•

Cambia el resultado, debido a que la memoria asigna un espacio aleatorio cada vez que lo ejecutas, pero el incremento siempre va a ser el mismo, que en este caso se hace bajo la convención hexadecimal

(

Gary Torres Martínez

student•

consulta, ¿cómo hace para copiar y pegar una línea en el vim?. Observo que digita v para una opción de visual, ¿pero luego para copiar y pegar?.

Platzerito De Platzi

student•

copiar: y pegar: p

Yehú Gómez

company_admin•

Hola @garytorresmartnez:

Para cortar o copiar una línea del archivo debemos mover el cursor hasta cualquier posición de la línea en cuestión y presionar dos veces la tecla d (dd) o y (yy), respectivamente. Para pegarla, nos desplazaremos hasta la línea deseada y presionaremos la tecla p. A continuación, veremos que la(s) línea(s) copiada(s) se insertará(n) inmediatamente debajo de la posición actual del cursor.
Para cortar o copiar más de una línea, debemos anteponer el número de líneas deseado a dd o yy. El procedimiento para pegar el contenido es igual al que describí en el punto anterior. Por ejemplo, para copiar la línea actual y las cuatro siguientes (cinco en total) debemos presionar 5yy.
Si deseamos cortar o copiar desde una posición dada dentro de una línea hasta el final de la misma, podemos utilizar la combinación de teclas d$ (la tecla d seguida por el signo peso) o y$, respectivamente. Para pegar el contenido, nos desplazamos hasta la posición deseada y presionaremos la tecla p.
Para deshacer los cambios realizados, utilizamos la combinación de teclas Esc + u (presionar Esc, luego u).

#include &lt;stdio.h&gt;

int main(int argc, char const *argv[]) {
  int * pi;
  int a = 5;
  int b = 1;

  pi = &amp;a;
  printf(&quot;Antes a = %d, &amp;a = %p, b = %d, &amp;b = %p, pi = %p\n&quot;, a, &amp;a, b, &amp;b, pi);
  pi--;
  *pi = 10;
  printf(&quot;Despues a = %d, &amp;a = %p, b = %d, &amp;b = %p, pi = %p\n&quot;, a, &amp;a, b, &amp;b, pi);
  return 0;
}

#include &lt;stdio.h&gt;// directiva del precompilador  libreria entrada y salida
int main()//funcion invocada cuando utilize el programa
{
  int n = 5; // Creamos una variable Tipo entero que Almacena un Valor de &quot;5&quot;
  int * pi = &amp;n; // creamos un Puntero a entero que tendra como valor la DIRECCION de la variable n 
  char cac= 'A'; // creamos variable de tipo char que almacenara CARACTERES
  char * pc = &amp;cac; // creamos un PUNTERO char que almacenara el contenido de la variable cac

  printf(&quot;Antes pi = %p y pc = %p\n&quot;, pi,pc);// muestra el antes de la incrementacion llamando a nuestros punteros de referencias
  pi++; //incrementamos nuestro PUNTERO entero
  pc++; // incrementamos nuestro PUNTERO Caracter
  printf(&quot;Despues pi = %p y pc = %p\n&quot;, pi,pc); //muestra el despues de la incrementacion llamando a nuestros punteros de referencias
}```

#include <stdio.h>

//funcion principal
int main(){

    //definimos la variable de tipo entero n con el dato numerico 5
    int n = 5;

    //definimos el puntero pi con la direccion de n
    int * pi = &n;
    
    //definimos la variable de tipo char c con el dato 'A'
    char c = 'A';
    
    //Definimos el puntero pc con la direccion de la variable c
    char * pc = &c;
    
    //imprimimos los datos originales recien creados
    printf("Antes pi = %p y pc = %p\n", pi, pc);
    
    //asignamos a pi un incremento en su dato para la direccion
    pi++;
    
    //asignamos a pi un incremento en su dato para la direccion
    pc++;

    //imprimimos los datos despues del incremento
    printf("despues del incrementeo pi = %p y pc = %p\n", pi, pc);
}

<int main()
{
    int *pi;
    int a= 5;
    int b= 1;

    pi = &a;
    printf("Antes   a = %d, &a = %p, b = %d, &b = %p, pi = %p \n", a, &a, b, &b, pi);
    pi++;
   // *pi = 10;
    printf("Despues a = %d, &a = %p, b = %d, &b = %p, pi = %p \n", a, &a, b, &b, pi);

    return 0;
}>

#include<stdio.h>

int main()
{
	int *pi;
	int a= 5;
	int b= 1;

	pi = &a;
	printf("Antes a = %d, &a = %p, b = %d, &b = %p, pi = %p \n", a, &a, b, &b, pi);
	pi++;
	// *pi = 10;
	printf("Despues a = %d, &a = %p, b = %d, &b = %p, pi = %p \n", a, &a, b, &b, pi);

	return 0;
}


> RESULTADO EN CONSOLA

Antes a = 5, &a = 0x7ffc4af849d0, b = 1, &b = 0x7ffc4af849d4, pi = 0x7ffc4af849d0 

Después a = 5, &a = 0x7ffc4af849d0, b = 1, &b = 0x7ffc4af849d4, pi = 0x7ffc4af849d4 

#include <stdio.h>

int main() {
    int * pi;
    int a = 5;
    int b = 1;

    pi = &a;
	printf( "Antes\n\t a = %d, &a = %p, b = %d, &b = %p, p = %p\n", a, &a, b, &b, pi );
	pi++;
	*pi = 10;
	printf( "Despues\n\t a = %d, &a = %p, b = %d, &b = %p, p = %p\n", a, &a, b, &b, pi );

    return 0;
}

int x = 0;
printf(&quot;%p\n&quot;, &amp;x); // Usa &amp; para obtener la dirección de una variable.
// (%p se sustituye por un puntero)
// =&gt; Muestra alguna dirección de memoria;

// Los tipos de puntero terminan con * en su declaración
int* px; // px es un puntero a un 'int'
px = &amp;x; // Almacena la dirección de x en px
printf(&quot;%p\n&quot;, px); // =&gt; Muestra alguna dirección de memoria

// Para obtener el valor de la dirección a la que apunta un puntero, pon
// * delante para desreferenciarle. 
printf(&quot;%d\n&quot;, *px); // =&gt; Muestra 0, el valor de x y de la dirección a la
                     //    que apunta px

// También puedes cambiar el valor al que está apuntando el puntero.
// Tenemos que meter la desreferencia entre paréntesis porque ++ tiene
// prioridad frente a *.
(*px)++; // Incrementa el valor al que apunta px en 1
printf(&quot;%d\n&quot;, *px); // =&gt; Muestra 1
printf(&quot;%d\n&quot;, x); // =&gt; Muestra 1```

#include <stdio.h>

int main(){
    int * pi;
    int a = 5;
    int b = 1;

    pi = &a;
    printf("Antes a = %d, &a = %p, b = %d, &b = %p, pi = %p\n", a, &a, b, &b, pi);
    pi--;
    * pi = 10;
 
    printf("despues a = %d, &a = %p, b = %d, &b = %p, pi = %p\n", a, &a, b, &b, pi);

}

Aritmética de punteros

Comprender qué es el lenguaje C

¿Dónde aprender C?

Introducción al curso

Herramientas para programar en C

Aprender los conceptos iniciales del lenguaje C

Compilación y ejecución de un programa en C

Tipos de datos

Definición de variables

Control de flujos

Uso y definición de funciones

Directivas de pre-compilador

Conceptos esenciales

Entender conceptos más profundos del lenguaje C

Punteros

Usos prácticos de los punteros

Aritmética de punteros

Arreglos

Strings

Strings y memoria

Parámetros de línea de comandos

Definición de tipos de datos estructurados

Alias de tipos de datos

Crear bibliotecas propias

Comprender los desafìos de la administración de la memoria

Manejo dinámico de la memoria

Cómo instalar Valgrind

Memory leaks y Garbage Collectors

Listas enlazadas

Ejercicio práctico de listas enlazadas

Liberando las listas enlazadas

Reto: Modifica el programa para que permita eliminar los nodos en los que se encuentre un determinado número

Usos prácticos

Cálculos complejos

Manejo de archivos de texto

Manejo de archivos binarios

Paralelismo

Comunicación entre procesos

Pipes

Sockets

Sockets: Código del servidor

Sockets: código de cliente

Comunicación vía sockets: ejecución

Conclusiones

Conclusiones