El tema de punteros puede ser complicado de entender la primera vez que te encuentras con él, te recomiendo ver esta clase las veces que sea necesario para comprenderlo, antes de pasar a la siguiente 😃
Memoria dinámica
El manejo de memoria
Punteros
Usando punteros
Estructuras de datos
Estructuras de datos
Creando nuestra primera estructura
Uniones y enumeraciones
Introducción a la Programación Orientada a Objetos
Qué es la Programación Orientada a Objetos
Creando nuestro primer objeto
El ciclo de vida de un objeto
Principios de la Programación Orientada a Objetos
Encapsulación
This
Static
Herencia
Herencia múltiple
Polimorfismo
Despedida
Conclusiones del curso
Los punteros son herramientas poderosas en el mundo de la programación, especialmente cuando se trata del manejo de la memoria dinámica. Almacenan direcciones de memoria, permitiendo acceder y modificar el contenido almacenado en esas ubicaciones. Esto es fundamental para el desarrollo de programas eficientes y flexibles.
La memoria RAM se organiza como una tabla de celdas. Cada celda tiene una dirección de memoria única e irrepetible que nuestro programa puede utilizar para almacenar variables de varios tipos, como enteros o caracteres. Por ejemplo, al almacenar un carácter como la letra 'a', este se sitúa en una dirección específica, como 0x0001, sin necesidad de aprender estas direcciones gracias al uso de nombres de variables.
En C++, los punteros se manejan mediante el uso de dos símbolos clave: el asterisco (*
) y el ampersand (&
). Estos permiten la definición y manipulación de punteros dentro del código:
Definición de un puntero: Para indicar que una variable es un puntero, se precede con un asterisco durante su declaración.
char* puntero;
Asignación de dirección de memoria: Se utiliza el símbolo de ampersand para obtener la dirección de una variable existente.
puntero = &letra;
Aquí, &letra
obtiene la dirección de memoria de la variable letra
y la almacena en puntero
.
El acceso y la manipulación de valores a través de punteros son elementos esenciales de su funcionalidad. Aquí se cubren las formas convincentes y eficientes de utilizarlos:
Desreferenciación: Usando el asterisco antes del nombre del puntero, puedes acceder al valor almacenado en la dirección apuntada.
char valor = *puntero; // Accede al valor 'a'
Obtención de dirección de un puntero: Colocando el ampersand antes del nombre del puntero, puedes encontrar su propia dirección de memoria.
char** direccionDePuntero = &puntero; // Dirección del puntero
Los punteros permiten eficiencia y control más allá de lo posible con las variables regulares. Al permitir manipular la memoria directamente, se optimiza el uso de recursos, y se permite el crecimiento o reducción dinámico de estructuras de datos, esenciales en aplicaciones que deben gestionar grandes volúmenes de información o manipular estructuras de datos complejas.
A medida que avanzas en tu aprendizaje sobre punteros, es esencial practicar con ejemplos prácticos y experimentar con distintas operaciones para fortalecer tus habilidades. ¡Continúa explorando y expandiendo tus conocimientos en programación!
Aportes 20
Preguntas 2
El tema de punteros puede ser complicado de entender la primera vez que te encuentras con él, te recomiendo ver esta clase las veces que sea necesario para comprenderlo, antes de pasar a la siguiente 😃
Este tema es muy complicado para mi, pero estoy decidido a entenderlo, te comparto este fragmento que nos ayudara a llegar lejos.
int main()
{
int numero = 5896;
int *puntero = №
cout << "Direccion de memoria del numero: " << &numero << endl;
cout << "Direccion del puntero: " << &puntero << endl;
cout << "Direccion de memoria a la que apunta el puntero: " << puntero << endl;
cout << "Valor del puntero: "<< *puntero << endl;
// cambiando el valor del numero desde el puntero
*puntero = 1111;
// Mostrando el valor cambiado
cout << numero ;
return 0;
}
El tipo de dato del apuntador debe coincidir con el de la variable cuya posición en memoria apuntan.
Siempre que queremos usar el apuntador debemos anteponer el asterisco (*) para indicar que usaremos el valor en la posición de memoria apuntada.
De no usar el asterisco el comportamiento sería impredecible. Estaremos haciendo uso de la dirección de memoria más no del valor almacenado en ésta.
Después de usar un puntero, especialmente si trabajamos con arreglos o matrices, es MUY recomendable liberar la memoria utilizada con la función delete (tal como en el ejemplo).
Un puntero o apuntador puede ser de cualquier tipo de dato, inclusive los podemos usar con tipos complejos.
Punteros, casi me cuesta Algoritmos y Estructuras de datos en C durante la Universidad.
#include <iostream>
#include <string>
using namespace std;
int main() {
char *puntero = NULL; //Declaramos un puntero
//Es recomendable inicializar un puntero en null, para detectar errores fácilmente
char letra; //Declaramos una variable primitiva
puntero = &letra; //Asignamos al puntero la dirección de memoria de la variable primitiva
*puntero = 'x'; //Modificamos la variable a través del puntero
cout << letra; //Muestra x por pantalla
}
Para declarar un punter usamos:
char *puntero;
Pero que pasa si lo declaramos como:
char* puntero;
Y que pasaria si declaramos dos variables en la misma linea? como en:
char* puntero, variable;
En este caso, variable es del tipo char o del tipo puntero a char?
La respuesta es: variable es del tipo char (no es un puntero).
Por este motivo conviene poner el * pegado a cada puntero y no pegado a char, como en char*.
Si queremos declarar dos punteros a char en la misma línea, quedaria:
char *puntero1, *puntero2;
Asi queda bien claro el tipo de cada uno y no da lugar a confusión.
los punteros tema super interesante es un tema complejo pero super poderoso.
El computador seria como un libro📘
Los punteros (*) serian como un capitulo 📑
La dirección de memoria (&) indicaría la posición donde se encuentra el capitulo #⃣
Los punteros son variables que se utilizan para almacenar direcciones de memoria, puntualmente las direcciones de memoria que fueron asignadas a variables convencionales en las que se almacenan datos de distinto tipo.
Una forma fácil de entender los punteros es compararlos con las direcciones de las casas en una calle. Cada casa tiene su propia dirección, de la misma manera que cada variable en C++ tiene una dirección de memoria. Los punteros son como un papel que guarda la dirección de una variable, así como un sobre con una dirección guarda una carta.
Por ejemplo, imagina que tienes una variable llamada “edad” y su dirección de memoria es 0x7fff5fbff7ec. Un puntero sería como un papel que dice “La dirección de la variable ‘edad’ es 0x7fff5fbff7ec”. De esta forma, podemos pasar la dirección de memoria de una variable como argumento a una función y manipular su valor desde allí.
Por ejemplo, podemos crear un puntero a la variable “edad” de la siguiente manera:
int edad = 25; // Creamos la variable 'edad' con un valor inicial de 25
int* puntero_edad = &edad; // Creamos un puntero que apunta a la dirección de 'edad'
Y luego podemos usar el puntero para obtener el valor de “edad” o cambiar su valor:
cout << "La edad es: " << *puntero_edad << endl; // Imprime el valor de 'edad' usando el puntero
*puntero_edad = 30; // Cambia el valor de 'edad' usando el puntero
cout << "La edad ahora es: " << edad << endl; // Imprime el valor de 'edad' después de cambiarla con el puntero
Punteros en C++
ahora recuerdo por que pocas personas entiende los punteros, si no lo ves de esta manera es dificil entenderlo
Cada celda de esta tabla imaginaria equivale a un 1 byte. Si un int equivale a 4 bytes, entonces dicha variable ocupará 4 celdas de la memoria. Es importante también mencionar que las direcciones en memoria de cada celda utilizan el formato hexadecimal, como por ejemplo:
0x7ffd97717714
Los punteros, dependiendo del sistema operativo (x86, x64) tienen un tamaño en memoria de entre 4 a 8 bytes.
Punteros: Son un tipo especial de variable que almacena una dirección de memoria.
char *puntero = &letra
Ejemplo sencillo:
#include <iostream>
using namespace std;
int main() {
int someVariable = 3;
// returns value stored in another variable memory address
int *somePointer = &someVariable;
// prints someVariable memory address
cout << somePointer << endl;
// prints someVariable value
cout << *somePointer << endl;
}
Los nombre de variable son un nombre alternativo para las direcciones de memoria. Las direcciones de memoria son únicas y almacenan valores.
La memoria dinámica es un espacio que puede variar por lo que no se le asigna un limite especifico.
Los punteros son tipos especiales de variables que se utilizan para almacenar la dirección de memoria de otra variable.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?