Definiendo una clase y creando sus instancias

Las clases, yo siempre las he pensado como un videojuego. A mí me gusta mucho Starcraft II que es un juego de estrategia. Por lo que una clase de ejemplo sería un soldado de los Terran, si hago 10 soldados cada uno de ellos tiene el mismo molde, pero si a uno de ellos le hacen daño a ese se le baja la energía, pero al resto de soldados no, por lo que sería un objeto independiente de los demás.

#include <iostream>

using namespace std;
class Cat//CLASE LLAMADA CAT
{
public: //lo que pueden conocer porque es PUBLICO
    string Name; // una viriable tipo caracter

   Cat() // CONSTRUCTOR es la funcion que se llama a la instacia que gato aparece en el mundo
   {
     Name = "Guapo";
   }
   Cat(string iName) // CONSTRUCTOR es la funcion que se llama a la instacia que gato aparece en el mundo
   {
     Name = iName;
   }
  void Meow() //ACCIONES funciones de mi clase y lo que hara es IMPRIMIR
  {
     cout<< Name<< " dice meow "<<endl;
  }
};
int main()
{
    Cat myfirstkitty;
    Cat mysecondkitty("Blacky");

    myfirstkitty.Meow();

    for(int i =0; i<3; i++)
    {
       mysecondkitty.Meow();
    }

    return 0;
}

Podemos crear varios constructores en nuestras clases de C++ para programar los casos donde recibimos o no recibimos parámetros. En JavaScript podemos usar valores por defecto para los casos donde no enviamos argumentos al constructor de nuestras clases pero no podemos crear atributos privados (en teoria no pero en la práctica si, yo solo digo 😅).

C++:

class Cat
{
        public string: Name;

        Cat()
        {
                Name = "Nombre por defecto";
        }

        Cat(string iName)
        {
                Name = iName;
        }
}

JS:

class Cat {
        constructor(name = "Nombre por defecto") {
                this.name = name;
        }
}

<code>
#include<iostream>

using namespace std;

class alumno{
public:
    bool aprobado;
    float mediaT = 0;
    string nombre;
    alumno(string aNombre,float parc,float inter){
        nombre = aNombre;
        mediaT = (parc*0.5) + (inter * 0.5);
    }
    bool Nota(){
        aprobado = false;
        if(mediaT >= 5){
            aprobado = true;
        }
        return aprobado;
    }
};

int main(){
    float parcial, intermedio;
    bool res;

    cout << "Introduce la nota del parcial:" << endl;
    cin >> parcial;
    cout << "Introduce la nota del intermedio:" << endl;
    cin >> intermedio;

    alumno Carlos("Carlos",parcial,intermedio);

    cout << Carlos.mediaT << endl;
    res = Carlos.Nota();
    if(res == true){
        cout << "Has aprobado" << endl;
    }
    else
        cout << "Has suspendido" << endl;
    return 0;
}
</code>

una clase es la abstraccion de un objeto del mundo real el cual posee atributos. Un ejemplo;
La clase Heroe, puede tener; nombre, vida, mana, XP, Lvl. etc.

Al menos eso es lo que creo.

#include <iostream>

using namespace std;

class cat
{
public:
    string name;

    cat()
    {
        name="Guapo";
    }
    cat(string namePuppy)
    {
        name=namePuppy;
    }

    void meow()
    {
        cout<<name<<" "<<"meow"<<endl;
    }
};

int main()
{
    string name;
    int i;


    cout<<"Dime el nombre de tu nuevo gatito: ";
    cin>>name;
    cat myFrirstPuppy;
    cat mySecondPuppy(name);

    cout<<"cual quieres leer(1/2): ";
    cin>>i;

    if(i==1){
         myFrirstPuppy.meow();
    }else{
        mySecondPuppy.meow();
    }
    return 0;
}```

![](

Una clase es una plantilla a partir de la cual creamos objetos…Es como un molde para un pastel. Tienes el molde pero a partir de ese molde puedes crear pasteles cada uno diferente… Uno de chocolate, otro de vainilla, etc… Pero aún así, todo fueron hechos con el mismo molde

Cada clase es un modelo que define un conjunto de variables (el estado), y métodos apropiados para operar con dichos datos (el comportamiento). Cada objeto creado a partir de la clase se denomina instancia de la clase. Las clases son un pilar fundamental de la programación orientada a objetos.

Hecho!!!

   void Meow ()
    {
        cout << Name << " dice: meow"<< endl;
    }
};

int main()
{
    Cat MyFirstKitty;
    Cat MySecondKitty ("Toriel");

    MyFirstKitty.Meow();

    for ( int i = 0; i< 3; i++){

        MySecondKitty.Meow();
    }

}```

Creí que iba a ser un poco más difícil entenderlo, pero con esta explicación creo que ha quedado totalmente claro. Emocionado por lo que se viene!

Una Clase es una plantilla

Una clase es como el molde donde se crearia un objeto; un objeto seria una instancia de una clase.

Clases suena como a especie de algo o un grupo definido de caracteristicas especificas

Este man es un loquillo con esos ejempos. 😉

una galleta es un objeto independiente

Clases: Es parecido a una funcion encierra bloque de codigos dentro de ella, pero en este caso sera utilizada para crear otros objetos, con la misma caracteristicas, es decir imagina tener un molde de galletas al poner la masa sobre la mesa el molde de galletas creara la misma forma una y otra ves, a las creaciones hechas por el molde o la clase se les llama Instancia

#include <iostream>

using namespace std;


class Pepe
{
    public:
    float Porcentaje;
    Pepe(float CantidadParte, float CantidadTotal)
    {
        cout<<"El Porcentaje es"<<endl;
        Porcentaje = (CantidadParte / CantidadTotal)*100;

    }
};



int main()
{
    float Cant1, Cant2;
    cout << "Escriba la parte del total"<<endl;
    cin >> Cant1;
    cout << "Escriba el total"<<endl;
    cin >> Cant2;
    Pepe Porciento(Cant1, Cant2);
    cout<<Porciento.Porcentaje<<"%"<<endl;
    return 0;
}```

Clase: Una clase puede ser una clasificación de objetos o una categoría. Por ejemplo: Si hablamos de una tortuga pertenecería a la clase reptil.

#include <iostream>

using namespace std;

class Fecha
{
private:
    int hora, mins, seg;
    long time;

public:
    Fecha(int,int,int);
    Fecha(long);
    void darFecha();
};
Fecha::Fecha(int _hora, int _mins, int _seg)
{
    hora=_hora;
    mins=_mins;
    seg=_seg;
}

Fecha::Fecha(long time)
{
    hora=int(time/10000);
    mins=int((time-hora*10000)/100);
    seg=int(time-hora*10000-mins*100);

}
void Fecha::darFecha()
{
    cout<<"El tiempo es: "<<hora<<':'<<mins<<':'<<seg<<endl;
}
int main()
{
    int h, m, s;
    long complet;

    cout<<"dime la hora: ";
    cin>>h;
    cout<<"dime los mins: ";
    cin>>m;
    cout<<"dime los segs: ";
    cin>>s;
    cout<<"dime la hora completa: ";
    cin>>complet;

    Fecha primeraHora(h,m,s);
    Fecha segundaHora(complet);
    cout<<"======================"<<endl;
    primeraHora.darFecha();
    cout<<" "<<endl;
    segundaHora.darFecha();

    return 0;

}```

Las funciones de las clases también suelen ser llamadas métodos.

Ya tengo conocimientos de POO porque ya he programado en Java. En un contexto en el que eres un chef que prepara galletas de diferentes formas, una clase podría pensarse como ese “molde” que te permite crear varias galletas de esa determinada forma.
O por ejemplo si quisieras hacer un programa que simule el juego de la batalla naval. Podrías crear una clase Ship. Y luego podrías instanciar (crear a partir de esa clase) varios ships. De esa forma estarías creando varios objetos de tipo Ship.

Clase: Tipo da dato complejo definido por el programador. Es una abstracción de un objeto cualquier y que posee diferentes atributos, En otras palabras es el molde que va definir un tipo especifico de objeto y los objetos creados (o inicializados) a partir de esa clase especifica se denominan Instancias.

Una clase es el molde o plantilla de donde saldrán nuestros objetos.

Hecho 😃

#include <iostream>
using namespace std;

class cat
{
 public:
 string name;

 cat ()
 {
     name="juanito";
 }

 cat(string Iname)
 {
    name=Iname;
 }
void Meuw()
{
    cout<<name<<"  dice Meuw"<<endl;
}

};

int main()
{
    cat primergato;
    cat segundogato("tory");

    primergato.Meuw();

    for(int i=0; i<3; i++)
    {
        segundogato.Meuw();
    }


    return 0;
}```

Clase: Conjunto de variables y funciones

#include <iostream>

using namespace std;

class Cat{
    public:
    string Name;

    Cat (){
        Name = "Guapo";
    }

    Cat (string iName){
        Name = iName;
    }

    //Se le da una funcipon al gato

    void Meow (){
        cout << Name << " dice meow"<<endl;
    }


};

int main()
{
    Cat MyFirstKitty;
    Cat MySecondKitty("Toriel");

    MyFirstKitty.Meow();

    for (int i = 0; i < 3; i++){
        MySecondKitty.Meow();
    }


    return 0;
}

Esta clase esta genial! la sencilla forma en que explica deja claro el funcionamiento de las clases de forma inmediata.

#include <iostream>

using namespace std;


class Cat
{
    public:
        string Name;

        Cat()
        {
            Name = "Guapo";
        }

        Cat(string iName)
        {
            Name = iName;
        }

        void Meow()
        {
            cout<< Name << " Dice Meow!"<< endl;
        }
};

int main()
{
    Cat MyFirtsKitty;
    Cat MySecondKitty("Angus");

    //cout<<"Me haz creado y soy un gato!  Mi nombre es: " << MyFirtsKitty.Name << endl;
    //cout<<"Me haz creado y soy tu segundo gato!  Mi nombre es: " << MySecondKitty.Name << endl;

    MyFirtsKitty.Meow();

    for(int i=0; i<4; i++)
    {
        MySecondKitty.Meow();
    }


    return 0;
}

Entonces una clase es una plantilla con la cual podemos crear distintos objetos con el fin de darle solución a determinados problemas. Esos objetos son instancias de la clase.

¿Las clases serian entonces lo mismo que una estructura? Porque son mas o menos parecidas, agradecería que me ayudaran con la duda.

En C++ también existen los valores por defecto, que se usan para que, en caso de que un cierto parámetro no se ingrese o especifique, entonces se tome ese valor por defecto.
Por ejemplo, los siguientes códigos son equivalentes:

//1era forma
Cat () {
            name = "Guapo";
 }
 Cat (string iName) {
            name = iName;
 }

O también:

//2nda forma
Cat (string iName = "Guapo") {
            name = iName;
 }

Excelente clase

clase: Componente del programa principal (main)

Clase: es la forma de como esta integrado un objeto

buena clase

<code>

#include <iostream>
class SuperVillano{
public:
int amigos;
bool tPelon, esListo, esPrieto;
std:: string allias, nReal;
void gradoMaldad (int){
if (0){
std::cout << “EXTREMADAMENTE MALO”<<std::endl;
}
else if (<=1){
std::cout << “Muy Malo”<< std::endl;
}
}
void Millonez(bool, bool){
if (true && true){
std::cout<<“EXTREMADAMENTE POBRE”<<std::endl;
}
else if ( true || true){
std::cout<<“Buena Millonez”<<std::endl;
}
else if (false && false){
std::cout<<“Millonez al millon”<<std::endl;
}
}
void Rikura(bool){
if (true){
std::cout<<“EXTREMADAMENTE RIKO”<<std::endl;
}
else if (false){
std::cout<<“No riko”<<std::endl;
}

}
};
int main (){
SuperVillano guason = SuperVillano();
std::cout<<“Guason:”<<std::endl;
guason.gradoMaldad(0);
guason.Millonez(false, false);
guason.Rikura(true);
return 0;
}

Gracias!

#include<iostream>
#include<conio.h>

using namespace std;

class Dog {
public:
    string Name;
        Dog()
    {
        Name = "Toby";
    }

    Dog (string iName)
    {
        Name = iName;
    }
    void Guau()
    {
        cout << Name << " GUAU GUAU GUAU " << endl;
    }
};

class Cat {
public: 
    string Name;
    Cat()
    {
        Name = "Gatitis";
    }

    Cat(string iName)
    {
        Name = iName;
    }
    void Meow()
    {

        cout << Name << " Dice guAUUU na mentira dice Miau" << endl;
    }

};


int main() {
    
    Cat MyFirstKitty;
    Cat MySecondKitty ("Sazi");
    Dog MyFirstDog;
    Dog MySecondDog; ("Poli");
   
    

    for (int i = 0; i < 3; i++)
    {
        MySecondKitty.Meow();
    }
    
    
    for (int i = 0; i < 5; i++)
    {
        MySecondDog.Guau();
    }

    getch();
    return 0;
}

Yo creo que clases debe ser un tipo de objeto que comparte caractéristicas como la clase pakiman en el curso de Freddy de programación básica.

Esto de las clases es algo nuevo para mi y aunque no le haya entendido del todo bien al principio, creo que fue una buena introducción. Muy buena clase

Así me quedo mi clase 😄

#include <iostream>
using namespace std;

class pets
{
   public:
    string type;
    string name;
    string action;

    pets(string itype, string iname, string iaction)
    {
      type = itype;
      name = iname;
      action = iaction;
    }

    void hablar()
    {
        cout << name << " Dice: Hola soy un " << type <<endl<<endl;
    }
};

int main()
{
 pets mascota1("Perro","Scooby", "ladrar");
 pets mascota2("Gato", "Cosmico", "maullar");

 cout << "Tipo de mascota: " << mascota1.type<< endl;
 cout << "Nombre: " << mascota1.name << endl;
 cout << "Accion: " << mascota1.action << endl <<endl;
 mascota1.hablar();

 cout << "Tipo de mascota: " << mascota2.type << endl;
 cout << "Nombre: " << mascota2.name << endl;
 cout << "Accion: " << mascota2.action <<endl<< endl;
 mascota2.hablar();

 return 0;
}

Resultado 😄

tengo una duda, el nombre del constructor debe tener el mismo nombre de la clase? de ser así, por que? saludos.

Que tu hermana menor entre en el momento en que dice “Guapo dice Miau” es algo priceless jajajaja no es queja, amo estos ejemplos. Vuelven la clase más amena y reduce el estrés. Más cuando te estresas por que no pusiste un “;” y por eso tu gato no maulla xD

*Mis apuntes sobre: “Definiendo una clase y creando sus instancias”

Es un tipo de dato complejo, definido por el programador. Se podría decir que una clase es un plano (blueprint) de un objeto.

¿Qué es una instancia? --> Es un objeto inicializado de una clase. Estos son una entidad única basada en una clase.

Les comparto mi código:

#include <iostream>

using namespace std;

class Cat
{
public:
    string name;
    Cat()
    {
        name="Cute";
    }
    Cat(string iName)
    {
        name=iName;
    }
    void meouw()
    {
        cout<<name<<": Says meow :3"<<endl;
    }
};

int main()
{
    Cat myFirstKitty;
    Cat mySecondKitty("Tori");

    myFirstKitty.meouw();
    for(int i=0;i<3;i++)
    {
        mySecondKitty.meouw();
    }

    return 0;
}

Excelente Clase!

Todo en c++ esta asociado con clases y objetos (y sus respectivos atributos y métodos).
Una clase es un tipo de dato complejo y funciona como un marco, contenedor o ‘blueprint’ para crear objetos (estos último son, a su vez, elementos o miembros que componen la clase).

Trayendo un ejemplo practico, y como aficionado al futbol, creo que una clase serian los jugadores de todo el Fifa. Cada equipo tiene N numero de jugadores; únicos e independientes, los cuales cuentan con distintas características y valores asignados. Aunque en el fondo, todos son jugadores.

la verdad que es un buen profe!