WOW, esta SUPER genial el poder tener un contador dentro del objeto sin necesidad de crear una función para que los cuente 😮
Memoria dinámica
Manejo de Memoria y Punteros en C++
Punteros en C++: Manejo y Uso de Memoria Dinámica
Uso de Punteros en C++: Variables y Memoria Dinámica
Estructuras de datos
Estructuras de Datos Personalizadas en C++
Creación y uso de estructuras y punteros en C++
Uniones y Enumeraciones en C++: Gestión Eficiente de Memoria
Introducción a la Programación Orientada a Objetos
Programación Orientada a Objetos en C++: Conceptos Básicos
Programación Orientada a Objetos: Creación de Clases y Objetos en C++
Ciclo de Vida de Objetos en C++: Constructores y Destructores
Principios de la Programación Orientada a Objetos
Encapsulación de Atributos en C++: Prácticas Seguras
Uso del Puntero This en C++ para Desambiguación y Autorreferencia
Atributos y Métodos Estáticos en Programación Orientada a Objetos
Herencia en C++: Implementación y Ejemplos Prácticos
Herencia Múltiple en C++: Implementación y Ejemplos Prácticos
Polimorfismo en Programación Orientada a Objetos
Despedida
Evaluación Final: Programación Orientada a Objetos en C++
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Atributos y Métodos Estáticos en Programación Orientada a Objetos
12/16Recursos
¿Qué son los atributos estáticos en programación orientada a objetos?
En la programación orientada a objetos, comprender los atributos estáticos es esencial para optimizar la gestión de datos dentro de una clase. A diferencia de los atributos normales que son específicos para cada instancia de la clase, los atributos estáticos son compartidos por todas las instancias. Esto significa que existe un único registro en memoria para todos, y cualquier modificación se verá reflejada en todas las instancias de la clase.
¿Cómo se declaran los atributos estáticos?
Para declarar un atributo estático, simplemente anteponemos la palabra clave static antes del tipo y nombre del atributo. Por ejemplo, si deseamos llevar un conteo de todas las instancias de una clase Persona, podemos crear un atributo estático de tipo entero:
static int numero_personas;
Este atributo servirá para contar cuántas veces se ha instanciado la clase Persona.
¿Cómo modificar el valor de un atributo estático?
Modificar un atributo estático dentro del constructor de una clase es una práctica común cuando se desea incrementar su valor cada vez que se crea una nueva instancia. Sin embargo, los atributos estáticos no pueden ser accedidos de forma dinámica desde dentro del cuerpo de la clase. En C++, necesitamos realizar estas modificaciones fuera de la declaración principal utilizando la sintaxis clase::atributo.
Para inicializar o modificar el valor de un atributo estático, se hace de la siguiente manera:
int Persona::numero_personas = 0;
Y en el constructor, incrementamos su valor:
Persona::numero_personas += 1;
Acceso y uso de métodos estáticos
Al igual que los atributos, los métodos también pueden ser estáticos. Esto significa que pueden ser llamados sin necesidad de crear una instancia de la clase.
¿Cómo definir métodos estáticos?
Para definir un método estático, se utiliza el mismo enfoque que los atributos. A continuación, se presenta cómo declarar un método estático afuera de la clase:
void Persona::saludar() {
std::cout << "¡Hola!" << std::endl;
}
En este caso, el método saludar estará asociado directamente a la clase Persona y no a instancias individuales.
¿Cómo acceder a los métodos estáticos?
Para acceder a los métodos estáticos, utilizamos el nombre de la clase seguido de dos puntos y el nombre del método:
Persona::saludar();
No es necesario crear una instancia de la clase para utilizar sus métodos estáticos, simplificando el acceso y permitiendo un uso más flexible de las funciones compartidas por todas las instancias.
Ventajas y consideraciones al usar miembros estáticos
Los miembros estáticos pueden ser extremadamente útiles en casos donde se requiere compartir información o funcionalidades entre todas las instancias de una clase. Sin embargo, hay que tener precauciones:
- Acceso desde fuera de la clase: Asegúrate de que los miembros estáticos que necesitan ser accedidos desde fuera de la clase están declarados en la sección
public. - Evitar errores de compilación: Configura correctamente los métodos y atributos estáticos para evitar errores de acceso incorrecto durante la compilación.
El manejo adecuado de los atributos y métodos estáticos no solo mejora la eficiencia del programa sino que también facilita el intercambio de mensajes y el seguimiento de datos globales dentro de las clases. ¡Continúa perfeccionando tus habilidades para aprovechar al máximo estos poderosos recursos en C++!
Aportes 6
Preguntas 2
Ordenar por:
Les dejo el codigó:
#include <iostream>
#include <string>
using namespace std;
class Person {
private:
string name;
int age;
public:
static int number_of_persons;
Person(string name, int age) {
this->name = name;
this->age = age;
number_of_persons += 1;
}
~Person() { cout << "Destruction" << endl; }
void change_name(string name) { this->name = name; }
void change_age(int age) { this->age = age; }
void say_hi() { cout << name << endl; }
};
int Person::number_of_persons = 0;
int main() {
Person p = Person("Zero", 14);
Person p2 = Person("Zero", 14);
Person p3 = Person("Zero", 14);
cout << Person::number_of_persons << endl;
p.say_hi();
}
Más sobre el Scope Resolution Operator ( :: ).
en general la clase esta muy bien pero seria mas facil si dejara el codigo para poder accerde a el como en el curso basico ya que es muy engorrozo tener que pausar la pantalla cada momento
**Variables estáticas**
Una variable estática es una variable que se almacena en la memoria de la aplicación y no en la pila. Esto significa que la variable existe solo durante la ejecución de la aplicación y no se crea y destruye cada vez que se llama a una función o método.
Las variables estáticas se utilizan a menudo para almacenar datos que deben ser accesibles para todas las instancias de una clase o función. Por ejemplo, una variable estática se puede utilizar para almacenar el número de instancias de una clase que se han creado.
**Funciones estáticas**
Una función estática es una función que no se asocia con ninguna clase. Esto significa que la función se puede llamar sin crear una instancia de una clase.
Las funciones estáticas se utilizan a menudo para realizar tareas que no requieren una instancia de una clase. Por ejemplo, una función estática se puede utilizar para calcular una fórmula matemática.
Codigo de ejemplo de la clase, saludo2
#include<iostream>
#include<string>
using namespace std;
class cls_persona {
private:
//propiedades
string nombre;
int edad;
public:
//Propiedades
static int num_personas;
//Constructor
cls_persona(
string vNombre,
int vEdad
);
//Destructor
~cls_persona(){
cout << "Destructor" <<endl;
}
//Metodos
cls_persona &met_cambiar_nombre(string vNombre){
this->nombre = vNombre;
return *this;
}
cls_persona &met_cambiar_edad(int vEdad){
this->edad = vEdad;
return *this;
}
void met_saludar();
};
//Llamadas Externa
int cls_persona::num_personas = 0;
cls_persona::cls_persona(
string vNombre,
int vEdad
){
this->nombre = vNombre;
this->edad = vEdad;
num_personas += 1;
}
void cls_persona::met_saludar(){
cout << "Mi Nombre es: " << nombre << endl;
cout << "Mi edad es: " << edad << endl;
}
/*********************[ main ]**********************/
int main() {
cls_persona per = cls_persona("Alexander Jair",36);
per.met_saludar(); cout << endl;
cls_persona *per2 = new cls_persona("Laura Sanguinetti",36);
//Llamada al destructor() ~
//delete per2;
//Ejemplo de Puntero - concatenado
per2->met_cambiar_nombre("Ximena").met_cambiar_edad(26).met_cambiar_nombre("Luz");
per2->met_saludar(); cout << endl;
cout << "El numero de personas:" << cls_persona::num_personas << endl;
}
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?