¿Cómo crear tu primera clase en programación orientada a objetos?
La programación orientada a objetos (POO) es un paradigma que nos permite estructurar nuestro código y datos de una manera clara y eficiente. Si bien el concepto puede parecer abstracto al principio, a través de ejemplos prácticos podremos comprender su utilidad real en el desarrollo de software.
¿Cómo definir una clase en el código?
Para comenzar a trabajar con POO, es fundamental aprender a crear una clase. Veamos cómo estructurarla en el código:
Declaración de la clase: Utilizamos la palabra class seguida del nombre de la clase, en este caso, Persona.
Encapsulación: Los atributos, por defecto, son privados en una clase, lo que significa que no se pueden acceder desde fuera de ella. Sin embargo, se puede modificar este comportamiento usando public para que sean accesibles externamente.
Atributos de la clase: Dentro de las llaves, definimos los atributos o propiedades de la clase, como nombre y edad. También es posible asignar valores iniciales.
Inicialización y uso de la clase: En la función principal (main), se puede crear una variable que instancie la clase Persona.
Persona p;p.nombre ="Diana";p.edad =26;std::cout << p.nombre << std::endl;// Salida: Diana
¿Cómo gestionar la memoria utilizando punteros?
El manejo de la memoria es crucial en el control de objetos. Podemos utilizar punteros para gestionar la creación de objetos dinámicamente.
Creando objetos dinámicamente: Usamos new para reservar memoria y el operador -> para acceder a los atributos o métodos.
La principal diferencia entre las memorias estática y dinámica es el momento en que se reserva; la memoria dinámica se asigna en tiempo de ejecución.
¿Cómo añadir comportamiento a los objetos?
Una de las principales ventajas de las clases respecto a las estructuras radica en que no sólo almacenan datos, sino que también pueden tener comportamientos o métodos.
Definiendo métodos: Podemos crear funciones dentro de la clase que realicen acciones específicas. En el siguiente ejemplo, añadimos un método saludar.
classPersona{public: std::string nombre;int edad;voidsaludar(){ std::cout <<"Hola, mi nombre es "<< nombre << std::endl;}};
Ejecutando métodos: Una vez definida la función saludar, podemos llamarla usando la instancia de Persona.
Persona* p =newPersona();p->nombre ="Diana";p->saludar();// Salida: Hola, mi nombre es Diana
¿Cómo personalizar cada instancia de una clase?
Cada instancia de una clase puede tener atributos diferentes, lo que significa que cada objeto mantiene su propia copia de datos, incluso si comparte el mismo código base.
Creando múltiples instancias: Al instanciar la clase con new, cada objeto es independiente. Por ejemplo, al tener una segunda persona:
Persona* p2 =newPersona();p2->nombre ="Ximena";p2->saludar();// Salida: Hola, mi nombre es Ximena
Manteniendo identificación exclusiva: Cada objeto puede tener atributos únicos, y al ejecutar métodos, como saludar, acceden a su propio estado.
La programación orientada a objetos facilita la tarea de modelar el mundo real en código, proporcionando una estructura clara para gestionar datos complejos y comportamientos asociados. Como desarrolladores, entender y aplicar estos principios nos permitirá escribir código más mantenible y robusto. ¡Sigue explorando y aplicando estas técnicas en tus proyectos!
Desde que aprendi POO, lo primero que se me viene a la mente es pokemon y justamente por eso xD
Este es el mejor ejemplo!!!
Me puse a pasar parametros en el metodo de saludo :eyes:.
#include <iostream>#include <string>using namespace std;classPersona{public: string nombre ="Luis"; int edad =22;voidsaludar(string persona){ cout <<"Soy "<< nombre << endl <<"¡Saludos, "<< persona <<"!"<< endl;}};int main(){Persona*persona1 =newPersona();Persona*persona2 =newPersona(); persona2->nombre ="Darkus"; persona1->saludar(persona2->nombre);return0;}
delete persona1;
delete persona2;
Al final del código
Gracias por el detallito, Efra :star2:
Cual es la diferencia entre declarar la clase con punteros y sin punteros?
Primero recuerda que no está declarando la clase, sino haciendo una instancia de la clase, es muy diferente declarar una clase a instanciarla 👀.
Ahora, con respecto a tu pregunta, la diferencia es que básicamente con un puntero tienes la dirección de memoria de dicha instancia, te recomiendo repasar la clase de punteros para que lo entiendas un poquito mejor. 😄
simple de la forma tradicional si tu declaras tus variables estas ocuparan un espacio en memoria la ocupes o no y estas solo liberaran su memoria al concluir el bloque de código o la finalización del programa, el problema viene si tienes no se unas 1000 o mas variables y créeme las vas a tener para empezar el primer problema seria ¿cuantas variables necesitara el programa realmente no lo sabes puede ser 1 o 1001 en el mejor de los casos si tienes 1 hay 999 que te roban memoria de manera inutil ese el problema de la variables tradicionales ""entre comillas"".
Con punteros no hay limites puedes hacer que vivan y mueran cuando quieras liberando memoria a tu antojo con delete. Segundo puedes crear tantos objetos de la clase como lo pida el programa es decir programas las condiciones para el programa reserve y gestione por si solo la cantidad de objetos que necesite es como append de las listas de Python (los vectores lista y maps de C++ se la inventaron pero detalles menores) solo que mejor ya que usar, eliminar, reusar, convertir, transferir, crear, repuntar, reasignar y deconstruir a complacencia .
Y tercero con los punteros puedes castear tus objetos y convertir un objeto persona y convertirlo aun objeto perro suena raro pero en C++ puedes, este es el principio y la base del polimorfismo
un ejemplo sin punteros
#include <iostream>#include <conio.h>#include <stdlib.h>using namespace std;classPersona{public: int edad =18; string nombre ="pepito";voidsaludar(){ cout <<"hola soy "<< nombre <<" y estoy saludando"<< endl;}voiddespedida(){ cout <<"Me despido atte: "<< nombre << endl;}}; int main(){Persona p =Persona();Persona p2 =Persona();Persona pokemon =Persona(); p2.nombre="parker"; pokemon.nombre="pikachuuu"; cout << p.nombre<< endl;// pepito cout << p.edad<< endl;// 18 p.saludar();//hola soy pepito y estoy saludando p2.saludar();//hola soy parker y estoy saludando pokemon.saludar();//hola soy pikachuuu y estoy saludando p.despedida();//Me despido atte: pepito p2.despedida();//Me despido atte: parker pokemon.despedida();//Me despido atte: pikachuuugetch();};
Mis notas de la clase:
Un objeto es una entidad que puede existir en el mundo físico o no. Y que tiene una clase (cierto tipo de objeto), nombre (identidad), propiedades (características descriptivas), métodos (cosas que el objeto puede hacer).
POO es una serie de conceptos que se van a implementar para saber como trabajar con el sofware.
Una estructura y una clase son básicamente lo mismo. La diferencia entre ellas es que que los miembros de una estructura son públicos por defecto y en una clase lo son privados.
La diferencia de los objetos y las estructuras es que a los objetos se les puede añadir comportamiento.
Cada nuevo objeto almacena su propia información.
gracias entendi mucho mejor Saludos desde Peru!
Les dejo el codigó :)
#include <iostream>#include <string>using namespace std;classPerson{public: string name ="Zero"; int age =14;voidsay_hi(){ cout << name << endl;}voidsay_age(){ cout << age << endl;}};int main(){Person p =Person(); p.say_hi(); p.say_age();}
Que alguien me saque de dudas exactamente que es void?
Void es un tipo de dato que significa que sabemos que no se retornará nada, así no se apartará memoria esperando un dato.
¿Cuál sería un ejemplo adecuado para utilizar un puntero al instanciar una clase en comparación con hacerlo sin un puntero?
Esto es importante ya que en las clases, parece que la única diferencia radica en cómo se llaman los atributos dentro de la clase.
básicamente:
p.nombre vs p->nombre
Código con punteros 🌠:
#include <iostream>#include <string>using namespace std;classPerson{public: string name =""; int age =0;voidgreet(){ cout <<"Hello "<<this->name <<"!";}};int main(){Person*person =newPerson(); person->name ="Bart"; person->age =10; person->greet();}
Elimina el puntero al finalizar la funcion!
Podemos reutilizar el puntero para crear nuevos objetos de esa clase 😁
#include<iostream>using namespace std;classPersona{private: string nombre; int edad;public:voidmostrar(){ cout<<nombre<<endl; cout<<edad<<endl;}voidsaludar(){ cout<<"Hola mi nombre es "<<nombre<<endl;};voidasignarDatos(string n, int e){ nombre = n; edad = e;}};int main(){system("cls");//para limpiar pantalla si estas en windows o "clear" si es LinuxPersona per;//inicia la persona de manera estatica per.asignarDatos("Lucas",28); per.mostrar(); per.saludar(); cout<<endl;/*Inicia un array de Puntero de tipo Persona
y el operador new crea el objeto de manera
dinamica en memoria, sera el lugar donde el
puntero almacene los datos que reciba. */Persona*p=newPersona(); p->asignarDatos("Ramon",25); p->mostrar(); p->saludar(); cout<<endl;/*Creamos una objeto persona extra, usando el mismo puntero y la memoria dinamica,
sin necesidad de asignarle un nombre al objeto nuevo*/ p=newPersona(); p->asignarDatos("Pedro",26); p->mostrar(); p->saludar();return0;}
Esto parece magia!
¿Que hay detras del funcionamiento de las clases? es decir ¿se usa una clase para crear el funcionamiento de como llamamos a las clases? ¿Es como con las estructuras de datos, que podemos ver como funcionan mediante la creacion de clases?
¿Son ecuaciones matemáticas duras y puras?
Si al final hay unos y ceros pero me refiero a que hay entre como llamo a la clase y esos unos y ceros.
Si podría decirse que las clases son como una expansión del concepto de estructura, pero va más allá porque internamente si las trata distinto el compilador.
Las clases son un concepto para facilitarle al ser humano el pensar sus programas, a diferencia de C, C++ se aleja un poco de la parte matemática de la programación, y se enfoca más en la facilidad de programar.
Justo una crítica que ha tenido la programación orientada a objetos es esa, que no es tan matemática, especialmente si se compara con otros paradigmas más matemáticamente orientados, como la programación Lambda o Programación Funcional.
Es importante para mi recomendarles que no utilicen new de manera discriminada.
El lenguage C tiene malloc y free para pedir memoria dinamica(heap) al sistema operativo, ya que C++ utiliza clases se agrego new y delete, los cuales no solo manejan la memoria dinamica sino que llama el constructor(new) y el destructor(delete).
La razon por la cual no se debe de utlizar malloc o new sin tener una razon muy buena es que C++ a diferencia de C tiene throwes decir puede lanzar una exception la cual interrupe el flujo del programa evitando que se llegue al delete respectivo.
Si se necesita utilizar memoria dinamica se puede utilizar dentro de otra clase contenedor, utilizar un smart pointer, una memory pool o memory arena.
Hola! les dejo aquí mi código de la clase, espero les ayude 🫡
#include <iostream>#include <string>using namespace std;classPersona{public: string nombre ="Emiliano"; int edad =19;voidsaludar(string nombreDos){ cout <<"Hola "+ nombreDos +"! Gusto en conocerte"<< endl;}};int main(){Persona*p =newPersona(); cout <<"Hola! me llamo "+ p->nombre +" y tengo "<< p->edad <<" años."<<endl;Persona*p2 =newPersona(); p2->nombre ="Sara"; p2->edad =18; cout <<"Cómo te llamas? "<< endl; p->saludar(p2->nombre);}
Les comparto el código que realice con este ejercicio jeje:
#include <iostream>#include <string>using namespace std;classpersona{public: string nombre =""; int edad =0;voidsaludar(){ cout <<"Hola, soy "<<nombre<<", y tengo "<<edad<<" años.";}};int main(){ persona p =persona(); cout <<"Cuál es tu nombre? "; cin >> p.nombre; cout <<"Cuál es tu edad? "; cin >> p.edad; p.saludar();}