Usando punteros

Les dejo el código de la clase 😃

#include <iostream>

using namespace std;

int main() {
  char character = 'A';
  char *pointer = &character;
  cout << (int *)&character << endl;
  cout << (int *)pointer << endl;
  cout << *pointer << endl;
}

Tambien les dejo mi repositorio con todo el código y notas del curso: UltiRequiem/oop-cpp-platzi

Lo interesante de los punteros es que puedes cambiar el valor de una variable del Main desde una función sin usar el return. Tengo entendido que esto no es muy buena práctica. Un breve ejemplo:

#include <iostream>
using namespace std;

void cambio(char *c){
    cout<< "El caracter recibido es: "<<*c<<endl;
    *c='q';
    cout<< "El caracter actual es: "<<*c<<endl;
}

int main(){
    
    char caracter = 'a';
    cambio(&caracter);
    cout<< "El caracter final es: "<< caracter;
    
    return 0;

} 

Código de la clase: 😃

#include <iostream>
using namespace std;

int main(){
  char letra = 'A';
  char *puntero = &letra;
  cout << (int *) &letra << endl;
  cout << (int *) puntero << endl;
  cout << *puntero;
}

basicamente, si usas el * obtienes el valor de la variable pero si esta cambia no se actualiza el valor que te entregan, pero si usas el & pasas la direccion de memoria y entonces si se actualiza el valor de variable que te entregan

Otra cosa interesante es la aritmética de punteros.

Un arreglo es en realidad un puntero que, valga la redundancia, apunta hacia la primera dirección de memoria del arreglo. Sabiendo que un int pesa 4 bytes y dicho arreglo se definió con una longitud de 3 espacios, entonces se sabe que avanzando 4 celdas en memoria se obtendrá el siguiente elemento, es decir, 1 salto equivale a 4 celdas para este caso.

int arreglo[] = { 10, -99, 4 };

Sabiendo que la siguiente expresión representa a la dirección en memoria del primer elemento:

cout << "Dir. hexadecimal del arreglo: " << arreglo << endl;

La siguiente expresión avanzará +1 y +2 saltos en memoria partiendo desde dicha dirección:

cout << "Dir. hexadecimal del arreglo en index 1: " << arreglo + 1 << endl;
cout << "Dir. hexadecimal del arreglo en index 2: " << arreglo + 2 << endl;

Para obtener el valor de este salto en memoria se recurre al operador de indirección (*puntero):

cout << "Contenido de index 0: " << *(arreglo + 0) << endl;
cout << "Contenido de index 2: " << *(arreglo + 2) << endl;

Comparo mi codigo:

#include <iostream>

using namespace std;

int main()
{
    char letra = 'A';
    char *puntero = &letra;

    cout << "El contenido de la variable letra es               : " << letra << endl;
    cout << "La direccion de la variable letra es               : " << (int *) &letra << endl;
    cout << endl;
    cout << "El contenido de la variable puntero es             : "  << (int *) puntero << endl;
    cout << "La direccion de la variable puntero es             : "  << (int *) &puntero << endl;
    cout << endl;
    cout << "El contenido de lo apuntado por puntero *puntero es: " << *puntero << endl;
    
    return 0;
}

Minuto 2:27, a eso se le conoce como cast, o casteo por su término españolizado.

para lo que no entendieron & se usa par buscar una dirección en memoria, mientras tanto * no almacena un lugar en memoria .

GitHub copilot me sugirio estas lineas is son super interesantes

#include <iostream>

using namespace std;

int main() {
  char letter = 'a';
  char *ptr = &letter;
  cout << "The value of letter is " << letter << endl;
  cout << "The value of *ptr is " <<  *ptr << endl;
  cout << "The value of ptr is " << ptr << endl;
  cout << "The value of &letter is " << &letter << endl;
  cout << "The value of &ptr is " << &ptr << endl;
  cout << "The value of &*ptr is " << &*ptr << endl;
}

Un granito mas en el camino a convertirme en programador.