Introducción a C++

1

Todo lo que aprenderás sobre C++

2

¿Qué es programar y por qué aprender C++?

Conceptos Generales de C++

3

La Historia de C++ y sus diferencias con C

Preparando el entorno de trabajo

4

Instalando Codeblocks

5

Pasos para instalar en mac

6

Ejecutando nuestro primer programa

7

¿Qué son las librerías STD? - Portada del Proyecto

Manejo de memoria

8

¿Qué es la memoria y tipos de datos?

9

Alojando variables en memoria

10

¿Cómo usar operadores?

11

¿Qué son los apuntadores?

12

Reto: Escribir un programa que calcule áreas.

Entrada de datos y funciones

13

¿Cómo introducir datos a nuestro programa?

14

¿Cómo usar condicionales?

15

Usando condicionales

16

¿Cómo encapsular código en funciones ?

17

¿Qué son los parámetros y como usarlos?

18

Reto: Juego narrativo implementando condicionales y entrada de datos.

Loops y arreglos

19

¿Qué son los arreglos?

20

¿Qué son los Loops?

21

Programando Loops

22

Loops , arreglos y arreglos bidimensionales

23

Dibujando el mapa de nuestro juego con arreglos

24

Manipulando mi jugador con inputs en arreglos unidimensionales

25

Arreglos bidimensionales

26

Reto: Moviendo a mi personaje en mi arreglo bidimensional

Lectura de Archivos

27

Creando y leyendo un archivo externo

28

Leyendo archivos externos

29

Reto: En el mapa, crear punto de inicio y salida del jugador

Programación Orientada a Objetos

30

¿Qué es POO?

31

Definiendo una clase y creando sus instancias

32

Encapsulación

33

Abstracción

34

Herencia

35

Propiedades de clase en herencia

36

Polimorfismo

Finalizando nuestro proyecto

37

Creación de personaje y archivo de encabezado

38

Moviendo mi personaje con entrada de datos

39

Mapa

40

Interacción entre el personaje y el mapa

41

Paredes

42

Optimizando trazado de mapa

43

Colisiones

44

Creando nuestra portada de juego

45

Tesoro y victoria

46

Conclusiones

47

Proyecto final

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

¿Qué son los apuntadores?

11/47
Recursos

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.

Aportes 94

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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;
}

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

1

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

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

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;

}

Excelente clase, así se debe explicar apuntadores!

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.

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?

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

#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 ;
}

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

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

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.

Wow! Aprendiendo cosas nuevas 😃

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 😄 hasta el momento me encanta este curso

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

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;
}

Imprimirá 3

Ejemplo con apuntador:

#include <iostream>

using namespace std;

int main()
{
    int Direccion = 3509;
    int SegundaDireccion = 1337;
    //Apuntador
    int* ApuntadorADir;
    //Consiguiendo la direccion en memoria de Direccion (guardar valor)
    ApuntadorADir = &Direccion;

    //Cambiando valor a la direccion en memoria
    *ApuntadorADir = 3;

    //Cambiando el apuntador a segunda direccion
    ApuntadorADir = &SegundaDireccion;

    //imprimir valor
    cout << "Valor del apuntador: " << endl;
    cout << *ApuntadorADir << endl;
    //imprimir la direccion en memoria
    cout << "Direccion en memoria: "<< endl;
    cout <<  ApuntadorADir << endl;
    return 0;
}

Por fin me quedaron claro los apuntadores, muy buena explicación

Es de las mejore explicaciones de punteros que he visto

Apuntadores: Son tipos de variables variables que almacenan la direccion del espacio en memoria que ocupa una variable, de esta forma nos permiten poder manipular una variable desde su raiz por ende con variables apuntadoras podemos usar variables fuera y dentro de una funcion

Hice este pedazo de código para que quedará un poco más claro

#include <iostream>

using namespace std;

int main()
{
    int number = 4, number2 = 8;
    int * 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 << endl; //*ptrNumber = number 


    ptrNumber = &number2;
    cout << "\nEl 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 << endl; //*ptrNumber = number2
    

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

}

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.

3

Pienso que al modificar el valor del apuntador modifico el valor de la variable a la que apunta

Anotación

La variable apuntadora debe tener el mismo tipo de la variable que va a ser apuntada. De lo contrario, esto generará un error de conversión, ya que C++ no puede convertir de un tipo a otro con la reasignación.

  • operador de apuntador: logra diferenciar la variable de una tipo apuntador.
    & ampersand: conseguir direccion especifica de memoria.

ejem:

int direccion = 3509; (asigna valor)

int* apuntadoradir; (apuntar una direccion)

apuntadoradir=&direccion;(esta dando direccion de la variable en memoria , la asigna la computadora)

*apuntadoradir = 3; (cambia la direccion de la variable en memoria y le coloca un 3 )

cout << direccion << endl; (muestra la direccion con la modificacion que hicimos en la linea anterior “direccion = 3”)

Creo que imprimira la direccion en memoria de segunda dirección.

Primera pregunta: 3509
Segunda pergunta: 1337

3

Gran clase de apuntadores!

imprimirá = 3

Imprime 3

Imprime la dirección de la memoria 0xFFFF

3…

mi apuntador original tenia 14 caracteres… a que se debe esto?

¿que es un apuntador? es una variable que guarda una dirección en memoria y que puede ser usada para modificar el valor que se encuentra en esa dirección

3

3

3

Yo pense que iva a imprimir 3.

Diablos, pensé que imprimiría 3509

Imprime 3

3509

Recuerdos de recorridos recursivos, reviven mis miedos mas grandes.

Imprime la direccion de la memoria

3

* Apuntador & Dirección de

Usando punteros 😄

#include <iostream>
using namespace std;

int main()
{
  int direction = 3000;
  // Un puntero que apunta a un entero 
  int *memoryDirection; 
  // Le asignamos la direccion de memoria de "direction"
  // Si "direction" cambia de valor entonces tambien lo hara el apuntador "*memoryDirection"
  memoryDirection = &direction;

  // Imprime la direccion de memoria que se le fue asignada
  cout << "La direccion de memoria es" << memoryDirection << endl;
  // Para imprimir el valor que apunta la direccion de memoria usamos "*"
  cout << "El valor de memoria es " << *memoryDirection << endl;
  
  return 0;
}

buen video!

Gracias

que buen video.

cuanto tiempo ha pasado, en mis tiempos los conocíamos como punteros XD

También se puede apuntar hacia funciones

#include <iostream>
using namespace std;

void imprimir_mensaje()
{
	printf("Imprimiendo un message\n"); 
}

int  main()
{
  void (*punt_funcion)(); //el primer parentesis es para el puntero
//el segundo es para los argumentos (la funcion no recibe ninguno)
  punt_func=&imprime;
  punt_func(); //Llama a funcion imprime
  return 0;
 }```

3, 1337

apuntadores que fasinante cuestion

Pienso que ya con esta explicaciones, terminé de entender el tema de los apuntadores.

Excelente clase. Muy motivado para proseguir con el resto del curso.

Hola, no estoy viendo este curso, pero que excelente explicación.

Los punteros son uno de los temas mas complicados cuando se va comenzando, sin embargo, para manipular ciertas estructuras de datos, el uso de punteros puede simplificar codigo.

3

A pesar de que conocía los conceptos de dirección de memoria y apuntador no entendía como lo usaban jajaja gracias.

#include <iostream>

using namespace std;

int main(){
    
    int Direccion = 1222;
    int* ApuntadorADir;
    ApuntadorADir = &Direccion;

    cout << "Esta es mi dirección: " << *ApuntadorADir << endl;
    cout << "Alojada en la memoria: " <<  &ApuntadorADir << endl;

    return 0;
} 

Esta es mi dirección: 1222
Alojada en la memoria: 0x7ffeebb65b90

genial no tenia mucha vuelta

IMPORTANTE El compilador lee las instrucciones linea por linea, desde arriba hasta el final

Va a imprimir 3

#include <iostream>
#include <string>
using namespace std;

int main()
{
	int coordenada1 = 75;
	int coordenada2 = 100;

	int* apuntador1; //declaramos que esta variables es un apuntador

	apuntador1 = &coordenada1; // obtenemos la direccion en memoria de la variable

	*apuntador1 = 3; // una vez que tenemos la direccion, modificamos los valores de esta

	apuntador1 = &coordenada2; // obtenemos la direccion de otra variable, utilizando nuestro apuntador

	cout << coordenada1 << endl; // imprimimos la coordenada con el valor ya modificado a traves del apuntador

	cout << apuntador1 << endl; // imprimimos la direccion de la siguiente variable coordenada
	
	return 0;
}

It seems that this project has not been built yet.
Do you want to build it now?

Me aparece este mensaje? a alguien le paso algo igual y me puede ayudar a ver que es.

3

3

#include <iostream>

using namespace std;

int main()
{
    int*num1;
    int*num2;
    int numInd=2;

    num1 = &numInd;
    num2 = num1;


    cout << *num1 << endl;
    cout << *num2 <<endl;
    return 0;
}

//regresa el valor de num1 y el de num2 con el mismo valor

estoy acostumbrado a C# y por ortografía a veces le pongo acentos a las variables cuando vienen en español como en éste ejemplo, jajaja.

imprime el 3

#include <iostream>

using namespace std;

int main()
{
    int Direccion = 390;
    int SegundaDireccion = 209;

    int * ApuntadorDir;

    ApuntadorDir = &Direccion;

    *ApuntadorDir = 4;

    ApuntadorDir = &SegundaDireccion;

    cout << *ApuntadorDir << endl;

    return 0;
}
#include <iostream>

using namespace std;

int main()
{   //Puntero
    int Direccion = 3509;
    int SegundaDir =1337;

    int* ApuntadorADir;

    ApuntadorADir = &Direccion;

    //Salida que el computador le da a Dirección
    cout << ApuntadorADir << endl;
    //Ya nos permire cambiar dirección sin tener que dirigirnos a ella directamente
    *ApuntadorADir = 3;

    cout << Direccion << endl;
    //cambiamos el apuntadorADIr igual a segundoDIr
    ApuntadorADir = &SegundaDir;

    cout << ApuntadorADir << endl;

    return 0;
}```

Consejos para usar apuntadores

  1. El tipo de dato del apuntador debe coincidir con el de la variable cuya posición en memoria apuntan. En el ejemplo vemos que tanto variable como apuntador son enteros.

  2. Siempre que queremos usar el apuntador debemos anteponer el asterisco (*) para indicar que usaremos el valor en la posición de memoria apuntada.

  3. 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.

  4. 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

  5. Un puntero o apuntador puede ser de cualquier tipo de dato, inclusive los podemos usar con tipos complejos.

Una sencilla y buena explicación de los apuntadores
Gracias!

3

3

Por si quieren otra explicacion les dejo el siguiente Video

Hice este pequeño ejemplo:

#include <iostream>

using namespace std;

int main()
{
    int Variable = 12345;

    int * ApuntadorAVariable = &Variable;

    cout << Variable << endl;

    cout << &Variable << endl;

    cout << ApuntadorAVariable << endl;

    cout << *ApuntadorAVariable << endl;

    *ApuntadorAVariable = 99999;

    cout << Variable << endl;

    cout << &Variable << endl;

    cout << ApuntadorAVariable << endl;

    cout << *ApuntadorAVariable << endl;

    return 0;
}

Aquí se puede observar lo que imprime la consola:

Les comparto el codigo con algunos comentarios para que puedan entender un poco mejor el tema 😃

#include <iostream>

using namespace std;

int main()
{
    int direccion = 3509;
    int segundaDireccion = 1337;

    int* apuntadorADir;                     // El * despues del tipo de dato indica que estamos creando una variable apuntador

    apuntadorADir = &direccion;             // apuntadorADir obtiene la direccion real del bloque donde están los 0 y 1 en la memoria RAM, esto se hace usando el & en la variable que deseamos obtener su ubicacion

    cout << direccion << endl;              // Esto imprime el valor simple de la variable
    cout << apuntadorADir << endl;          // Esto imprime la direccion real de la variable direccion

    *apuntadorADir = 3;                     // mete un 3 a la variable con la direccion de memoria que obtuvimos
    cout << direccion << endl;              // Esto imprime el valor simple de la variable, deberia de mostrar el valor ya actualizado

    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;
}

Quizas les sea de ayuda

#include <iostream>

using namespace std;

int main()
{
    int direccion = 3509;
    int direccionDos = 1337;
    cout << direccion << endl;

    // Extraigo la ubicacion en memoria de direccion en la varibale apuntador "ApuntadorDirecc"
    int* ApuntadorDirecc;
    ApuntadorDirecc = &direccion;
    cout << ApuntadorDirecc << endl;

    // Asigno un valor diferente en ese espacio de memoria
    *ApuntadorDirecc = 3;
    cout << direccion << endl;

    // Imprimo el nuevo valor que se encuentra en la direccion "ApuntadorDirecc"
    ApuntadorDirecc = &direccionDos;
    cout << *ApuntadorDirecc <<endl;
    return 0;
}

es muy muy util

Para los que se pregunten ¿Por qué al final imprimió el pantalla el valor de la variable y no la dirección en memoria? Muy sencillo, cuando usamos la variable apuntadorADir (sin *) nos va a dar la dirección en memoria donde esta almacenada y cuando usamos la misma variable pero con * (*apuntadorADir) nos da como resultado el valor que se encuentra almacenado en esa dirección de memoria.

PUNTEROS
.
Cuando declaramos variables en realidad estamos asignando nombres a direcciones de memoria que van a contener un valor x
.
Una variable tiene:
.

Entonces un puntero es UNA VARIABLE que CONTIENE DIRECCIONES DE MEMORIA

El profe me cae bien

Creo que va a imprimir el numero 3509.

en el caso de los apuntadores los podemos hacer cuando en un juego tenemos datos de un jugador, entonces lo que hara es que se le pide a la persona un nombre en el juego y cuando la persona lo cambie por que no le gusto el anterior se sumara el ultimo dato podria ser…

en la parte del video donde dice que guarda 3 o 3509, sucede por que los apuntadores o punteros guardan informacion, entonces si colocamos dobles datos como en la clase se cambia el primero por el ultimo dato.

Mis apuntes sobre: ¿Qué son los apuntadores?
Un apuntador es una variable que guarda una dirección de memoria. La referencia a esta dirección de memoria puede ser usada para modificar el valor dentro de ella.
Operadores:

  • -> apuntador
    & -> ampersand (conseguir la dirección de una variable)

Que manera tan facil de entender sobre punteros, el curso de Introduccion a C 2019 me pareció mas confuso!

Mandé a imprimir en cada paso para que se entienda la diferencia entre:
ApuntadorADir=&Direccion; (Obtiene la direccion de la ram)
y *ApuntadorADir (Obtiene el valor que hay en dicho espacio de memoria)
Espero esto les esclarezca un poco.

#include <iostream>
using namespace std;

int main()
{
	int Casa=3509;
	int Casa2=1337;
	int* ApuntadorADir; //variable apuntador
	
	ApuntadorADir= &Casa;//consigue la direccion en la memoria de la variable Casa
	cout<<ApuntadorADir<<endl;//la imprime
	cout<<*ApuntadorADir<<endl<<endl;//a lo que apunta(su valor)
	
	*ApuntadorADir=3;// a lo que apunta; es decir, al valor de casa, se le asigna 3
	cout<<Casa<<endl;//imprime el valor asignado(3);
	cout<<ApuntadorADir<<endl; //imprime la variable apuntador que contiene la direccion de casa (linea 10)
	cout<<*ApuntadorADir<<endl<<endl;// a lo que apunta la variable (el valor de casa que es 3)
	
    ApuntadorADir= &Casa2; // Ahora a la variable apuntador se le asigna la direccion de la casa 2
	cout<<ApuntadorADir<<endl;//imprime la direccion
	cout<<*ApuntadorADir<<endl;//imprime a lo que apunta (su valor que es 1337)

	return 0;
	
}

¿De que sirven los apuntadores de memoria? Si podemos cambiar el valor de la variable que estemos utilizando directamente.