Uso de Apuntadores para Manipulación de Memoria en Programación

Clase 11 de 47 • Curso Práctico de C++

Contenido del curso

Introducción a C++

Conceptos Generales de C++

3
Historia y uso del compilador GCC en programación
01:43 min

Preparando el entorno de trabajo

Manejo de memoria

Entrada de datos y funciones

Loops y arreglos

Lectura de Archivos

Programación Orientada a Objetos

Finalizando nuestro proyecto

Tomar examen

Resumen

Los apuntadores son como cualquier otra variable pero, en vez de guardar texto, números o cualquier otro tipo de dato, pueden acceder a la dirección en memoria del resto de nuestras variables. Esto significa que podemos modificar la posición donde se guardan nuestras variables y también que tenemos mucho más control sobre ellas.

Comentarios

Josué Eduardo Apén Bal

student•

Ya comentado, quizá quede más claro ...

<code>
#include <iostream>

using namespace std;

int main()
{
    // & Obtiene la direccion de memoria de una variable
    // * Obtiene lo que hay en la direccion de memoria que se le indica

    
    int Direccion = 3509l;
    int SegundaDireccion = 1337;// Declaracion de variables

    int* ApuntadorADir;  // Variable apuntador

    ApuntadorADir = &Direccion;  // La variable obtiene la direccion de memoria

    *ApuntadorADir = 3; // Lo que habia en dicha direccion ahora es igual a 3
    ApuntadorADir = &SegundaDireccion; // Obtiene la direccion de memoria de SegundaDireccion
    
    cout<< *ApuntadorADir<<endl; // Imprime en pantalla lo que hay en la Direccion de memoria de  SegundaDireccion


    return 0;
}

Dilan Santiago Ariza Cañon

student•

Gracias men :D

José Manuel Rosales Ríos

student•

muchísimas gracias en serio, gracias a ti comprendí mejor esta clase :D

marco antonio

student•

una nota por si la necesitan asi se declara un puntero

int* puntero; in variable = 1;

asi se asigna una direcion

puntero = &variable;

asi se le saca el contenido de la dirección de la variable a la que apunta el puntero

cout << *puntero;

muestra en consola

se usa el asterisco para decir dame lo que contiene esa dirección si no se usara en ves de retrasarte lo que contiene esa dirección lo que te devolvería seria la dirección de memoria de la variable

cout << puntero;

muestra en consola

AF55425asdfgghj XD ya saben una direccion

Andres Condezo Monge

student•

Buen resumen, gracias.

Yair Enrique Mendoza Mendoza

student•

Le agregue las dos "formas" en las que se está imprimiendo el apuntador

cout << *ApuntadorADir << endl; // Imprime en pantalla lo que hay en la Direccion de memoria de  SegundaDireccion   (1337)
    cout << ApuntadorADir << endl; //Imprime la dirrecion fisica donde esta guardada la variable SegundaDireccion (0x28fef4    en mi caso)```

________________________________________________

#include<iostream>

using namespace std;

int main() { // & Obtiene la direccion de memoria de una variable // * Obtiene lo que hay en la direccion de memoria que se le indica

int Direccion = 3509l;
int SegundaDireccion = 1337;// Declaracion de variables

int* ApuntadorADir;  // Variable apuntador

ApuntadorADir = &Direccion;  // La variable obtiene la direccion de memoria

*ApuntadorADir = 3; // Lo que habia en dicha direccion ahora es igual a 3
ApuntadorADir = &SegundaDireccion; // Obtiene la direccion de memoria de SegundaDireccion

cout << *ApuntadorADir << endl; // Imprime en pantalla lo que hay en la Direccion de memoria de  SegundaDireccion
cout << ApuntadorADir << endl; //Imprime la dirrecion fisica donde esta guardada la variable SegundaDireccion 

return 0;

}

Ramiro Nicolas DAccorso Rosati

student•

Muchas gracias! Me había quedado esa duda!!! Medio que fue confuso el profe en esto!!

Valentina Orejuela

student•

Gracias!

Danelia Sanchez Sanchez

student•

En el caso de los apuntadores (punteros), el * se le conoce como operador de indirección y permite acceder al valor de la variable a la que apunta o asignarle un nuevo valor. Tener cuidado de no omitirlo pues estarías obteniendo la dirección de memoria.

int valor = 5;
int *ptr = &valor;
cout << valor << endl; // imprime 5
cout << *ptr << endl; // imprime 5

https://www.programiz.com/cpp-programming/pointers

Matías Wasiak

student•

Gracias!

Ricardo Antonio Prada Rojas

student•

Excelente clase, así se debe explicar apuntadores!

Jose Rojas Acevedo

student•

Habría sido mejor, que si se quiere ser más didáctica y menos confusa la explicación, no poner el nombre de las variables como 'direccion', para que no haya una confusión de términos.

Yeraldo Arriola Plascencia

student•

Deberían poner ejercicios después de cada video para reforzar lo visto en el video, porque no me quedo muy claro este vídeo.

Beicker Jesus Zambrano Escalona

student•

Esto a mí me parece lo mismo que crear otra variable y asignarle el valor de la creada de antemano. ¿Por qué yo querría reescribir el contenido de un lugar específico de la memoria ram de esta manera? ¿Para qué me puede servir esto en el desarrollo de videojuegos, por ejemplo?

Juan Castro

teacher•

¡No los subestimes! Yo tampoco entendía muy bien sus casos de uso pero, de verdad, resultan sumamente útiles...

Por ejemplo: Imagina que quieres modificar el valor de una variable desde una función diferente a donde la variable fue declarada inicialmente. ¿Cómo lo haces? Con apuntadores es literalmente magia.

Un ejemplo: :point_down:

String to Char in C++

Danelia Sanchez Sanchez

student•

Tal como dice @juandc, en algún momento necesitarás modificar el valor de tus variables en una función y eso lo haces con apuntadores. En C/C++ los argumentos que se pasan a una función (los valores de las variables) son copias de los originales y cualquier modificación que hagas con ellos en la función no altera su valor original. A esto se le llama paso por valor, pero en el paso por referencia los argumentos deben ser direcciones de memoria de las variables a modificar y los apuntadores almacenan direcciones de memoria. En este enlace puedes leer más al respecto. Los apuntadores te permiten gestionar memoria de forma dinámica, es decir, puedes reservar y liberar espacio de memoria según se necesite durante la ejecución del programa. Un arreglo te permite guardar una cantidad específica de elementos pero, ¿y si necesitas eliminar elementos? puedes cambiar su valor pero el espacio de memoria reservado no se elimina hasta que termina el programa. Con apuntadores es diferente. Si quisieras hacer un videojuego donde tu héroe elimina a los enemigos podrías crearlos de forma dinámica y cuando son destruidos, liberar la memoria que ocupaban.

Juan Castro

teacher•

Un recurso interesante sobre los apuntadores: http://www.utm.mx/~mgarcia/PE7(Apuntadores).pdf

Alejandro Urrea Giraldo

student•

Para quienes deseen complementar la información sobre punteros, les dejo el link de una excelente clase del curso de C, con el profesor Mauro Chojrin.

https://platzi.com/clases/1740-lenguaje-c/24212-punteros/

El concepto de punteros o apuntadores en C, también aplica para C++, por lo cual la explicación es muy relevante

Hernan Rodriguez

student•

Mal profe explica demasiado rápido y da por hecho que entendimos todo a la primera

Irving Juárez

student•

Se entiende mejor la explicación en esta clase que en la del maestro Mauro

Miguel Angel Lozano Alvarez

student•

#include <iostream>

using namespace std;

int main(){
    int milk_price = 10;
    int* new_price;

    new_price = &milk_price;
    *new_price = 15;

    cout << milk_price <<endl;
    return 0 ;
}

David Lara

student•

en el curso de introduccion a C de 2019 no pude entender el concepto de apuntadores.... y si que es sencillo...

Julio Cardenas

student•

Salida:

Darwin 🎊

student•

Profe tengo algo que me esta rompiendo la cabeza!Cual los parametros de la funciones se destruyen al finalizar la funcion?

Hector Esau M

student•

No hay parametros que se destruyen en una función, tal vez lo que te confunde es el alcance de las variables, dependiendo en donde crees la variable es hasta donde vivi y por cuales funciones pueden ser accedidas Globales Son aquellas que se crean antes del int main() Locales Son las que se crean dentro de una función*

Aquí hay más información

Alejandro Urrea Giraldo

student•

En C/C++, los valores que se envían como parámetros a una función, pueden pasarse por valor o por referencia.

Cuando un parámetro se pasa por valor , realmente lo que se le envía a la función es una copia del valor almacenado en la variable. Esta copia existe únicamente en el ámbito de la función; al terminar de ejecutar todas las instrucciones de la función, la copia desaparece. Cabe resaltar que la copia ocupa un lugar de memoria diferente al de la variable original que se pasó como parámetro. Por este motivo, cualquier cambio que se haga sobre el valor de la copia mientras se ejecute la función, no afectará el valor de la variable original.

Sin embargo, cuando un parámetro se pasa por referencia, lo que se envía es un puntero que apunta hacia la dirección de memoria de la variable original que se pasa como parámetro. En este caso, cualquier cambio que se realice a la variable dentro de la función afectará el valor original de la variable (ya que en esencia es la misma dirección de memoria, osea la misma variable).

Le dejo un ejemplo para que pueda notar mejora la diferencia

Espero haber contestado su pregunta

Raul Vazquez Montiel

student•

cual es la diferencia entre asignar : ApuntadorADir=algo; y *ApuntadorADir=algo; ??

Carlos Nassif Trejo Garcia

student•

Una es para conseguir la mamoria, asignarlo. Y la otra es para que vaya a la memoria a la que apunta y escribir algo en ella.

Es decir, en la primera tomamos la dirrecion y se la asignamos a puntadorADir

Mientra que en la segunda, vamos a la direccion real a la que apunta, y ahi escribimos el 3, sin embargo la vaiabrle Apuntador sigue apuntando a esa direccion

Hector Esau M

student•

En la primera le estas asignando otro lugar de memoria y debes de usar el operador & En el segundo le estas asignando otro valor a la variable que se esta apuntando Hice este pedazo de codigo para que quedará más claro correlo y creo que te ayudara mucho

#include <iostream>

using namespace std;

int main()
{
    int number = 4, number2 = 8;
    int * ptrNumber = &number;

    number = 8;
    cout << "El valor de number es :" << number //number =4
         << "\nEl valor de number2 es:" << number2 //number2 = 8
         << "\nEl valor de ptrNumber es:" << ptrNumber // ptrNumber = Lugar x de memoria, siempre es diferente
         <<"\nEl valor de *ptrNumber es:" << *ptrNumber; //*ptrNumber = number 

    ptrNumber = &number2;
    cout << "El valor de number es :" << number //number =4
         << "\nEl valor de number2 es:" << number2 //number2 = 8
         << "\nEl valor de ptrNumber es:" << ptrNumber // ptrNumber = Lugar x de memoria, siempre es diferente
         <<"\nEl valor de *ptrNumber es:" << *ptrNumber; //*ptrNumber = number2
    
    *ptrNumber = number;
    cout << "El valor de number es :" << number //number =4
         << "\nEl valor de number2 es:" << number2 //number2 = 8
         << "\nEl valor de ptrNumber es:" << ptrNumber // ptrNumber = Lugar x de memoria, siempre es diferente
         <<"\nEl valor de *ptrNumber es:" << *ptrNumber; //*ptrNumber = number2
    return 0;

}

Manuel Alejandro Aguilar Téllez Girón

student•

Yo conocía al apuntador * como operador de indirection Y al ampersand como operador de dirección o referencia

David Perez

student•

La variable Dirección ahora es 3 porque al decir que la variable ApuntadorADir guarda la dirección en memoria de la variable Direccion le estamos dando a ApuntadorADir la capacidad de modificar lo que esté en esa dirección.

Jesús Romero Rivera

student•

Wow! Aprendiendo cosas nuevas :)

Ezequiel Choque

student•

Falle en los 2 mini retos que dio el profe :( pero aprendí algo muy loco como dicen mis compañeros es realmente interesante para mas adelante implementarlo :D hasta el momento me encanta este curso

Rafael Pardo Rodriguez

student•

No hay que crear necesariamente una variable, se puede imprimir directamente el lugar en memoria, solo se crea una varaible con el apuntador para poder interactuar con ella directametne.

#include <iostream>

int main()
{
    int numb1 = 20;
    int* apuntadorNumb1 = &numb1;

    std::cout << numb1 << std::endl;
    std::cout << &numb1 << std::endl;
    std::cout << apuntadorNumb1 << std::endl;

    return 0;
}

<code>
#include <iostream>

using namespace std;

int main()
{
    // & Obtiene la direccion de memoria de una variable
    // * Obtiene lo que hay en la direccion de memoria que se le indica

    
    int Direccion = 3509l;
    int SegundaDireccion = 1337;// Declaracion de variables

    int* ApuntadorADir;  // Variable apuntador

    ApuntadorADir = &Direccion;  // La variable obtiene la direccion de memoria

    *ApuntadorADir = 3; // Lo que habia en dicha direccion ahora es igual a 3
    ApuntadorADir = &SegundaDireccion; // Obtiene la direccion de memoria de SegundaDireccion
    
    cout<< *ApuntadorADir<<endl; // Imprime en pantalla lo que hay en la Direccion de memoria de  SegundaDireccion


    return 0;
}

cout << *ApuntadorADir << endl; // Imprime en pantalla lo que hay en la Direccion de memoria de  SegundaDireccion   (1337)
    cout << ApuntadorADir << endl; //Imprime la dirrecion fisica donde esta guardada la variable SegundaDireccion (0x28fef4    en mi caso)```

________________________________________________

int Direccion = 3509l;
int SegundaDireccion = 1337;// Declaracion de variables

int* ApuntadorADir;  // Variable apuntador

ApuntadorADir = &Direccion;  // La variable obtiene la direccion de memoria

*ApuntadorADir = 3; // Lo que habia en dicha direccion ahora es igual a 3
ApuntadorADir = &SegundaDireccion; // Obtiene la direccion de memoria de SegundaDireccion

cout << *ApuntadorADir << endl; // Imprime en pantalla lo que hay en la Direccion de memoria de  SegundaDireccion
cout << ApuntadorADir << endl; //Imprime la dirrecion fisica donde esta guardada la variable SegundaDireccion 

return 0;

#include <iostream>

using namespace std;

int main()
{
    int number = 4, number2 = 8;
    int * ptrNumber = &number;

    number = 8;
    cout << "El valor de number es :" << number //number =4
         << "\nEl valor de number2 es:" << number2 //number2 = 8
         << "\nEl valor de ptrNumber es:" << ptrNumber // ptrNumber = Lugar x de memoria, siempre es diferente
         <<"\nEl valor de *ptrNumber es:" << *ptrNumber; //*ptrNumber = number 

    ptrNumber = &number2;
    cout << "El valor de number es :" << number //number =4
         << "\nEl valor de number2 es:" << number2 //number2 = 8
         << "\nEl valor de ptrNumber es:" << ptrNumber // ptrNumber = Lugar x de memoria, siempre es diferente
         <<"\nEl valor de *ptrNumber es:" << *ptrNumber; //*ptrNumber = number2
    
    *ptrNumber = number;
    cout << "El valor de number es :" << number //number =4
         << "\nEl valor de number2 es:" << number2 //number2 = 8
         << "\nEl valor de ptrNumber es:" << ptrNumber // ptrNumber = Lugar x de memoria, siempre es diferente
         <<"\nEl valor de *ptrNumber es:" << *ptrNumber; //*ptrNumber = number2
    return 0;

}

#include <iostream>

int main()
{
    int numb1 = 20;
    int* apuntadorNumb1 = &numb1;

    std::cout << numb1 << std::endl;
    std::cout << &numb1 << std::endl;
    std::cout << apuntadorNumb1 << std::endl;

    return 0;
}

Uso de Apuntadores para Manipulación de Memoria en Programación

Introducción a C++

Programación de Videojuegos con C++ desde Cero

Programación en C++: Fundamentos y Aplicaciones Prácticas

Conceptos Generales de C++

Historia y uso del compilador GCC en programación

Preparando el entorno de trabajo

Instalación de Code::Blocks en Windows paso a paso

Instalación de CodeBlocks en Mac paso a paso

Creación de un Proyecto de Consola en C++ Paso a Paso

Uso de Librerías y Entrada/Salida en C++

Manejo de memoria

Memoria y Tipos de Datos en Computadoras y Programación

Variables y tipos de datos en programación básica

Operadores Aritméticos y Lógicos en Programación