Un atributo estático de una clase se crea independientemente a que se definan objetos de la misma, y en el caso que se creen más de un objeto de dicha clase dicho atributo es compartido por todas las instancias.
Como vemos es muy distinto el funcionamiento a los atributos de la clase que hemos visto hasta ahora. Un atributo estático pertenece a la clase pero su existencia es independiente a que se definan o no objetos de la misma.
Plantear una clase que defina dos atributos, definir a uno de tipo estático. Crear dos objetos de dicha clase y modificar e imprimir dichos atributos.
#include<iostream>
using namespace std;
class Prueba {
int x1;
static int x2;
public:
Prueba(int v1, int v2) { x1 = v1; x2 = v2; };
void imprimir();
};
int Prueba::x2;
void Prueba::imprimir()
{
cout << x1 << "-" << x2 << "\n";
}
int main()
{
Prueba prueba1(1, 1);
prueba1.imprimir(); // 1 1
Prueba prueba2(20, 20);
prueba1.imprimir(); // 1 20
return 0;
}
Este proyecto lo puede descargar en un zip desde este enlace : AtributoEstatico1.zip
Para declarar un atributo estático tenemos que agregar la palabra clave static:
class Prueba {
int x1;
static int x2;
public:
Prueba(int v1, int v2) { x1 = v1; x2 = v2; };
void imprimir();
};
Y luego fuera de la clase crearlo con la siguiente sintaxis:
int Prueba::x2;
Como vemos no alcanza con solo declararlo dentro de la clase debemos definirlo fuera de la clase. Si necesitamos inicializarlo con un valor podemos hacerlo en este momento:
int Prueba::x2=100;
Se puede inicializar el atributo estático ya que se reserva espacio para esta variable indistintamente se creen o no objetos de la clase que contiene dicho atributo estático.
En la main estamos creando un objeto de la clase Prueba, llamando al constructor y finalmente imprimiendo los dos atributos en el método imprimir():
Prueba prueba1(1, 1);
prueba1.imprimir(); // 1 1
No hay dudas porque se muestran los dos unos en pantalla. Tanto el atributo común como el estático reciben el 1.
Ahora creamos otro objeto de la clase Prueba y le pasamos al constructor los valores 20 y 20:
Prueba prueba2(20, 20);
Si llamamos nuevamente al método imprimir() pero del objeto prueba1 (que había impreso anteriormente un 1-1):
prueba1.imprimir(); // 1 20
Vemos que cuando se imprime el atributo estático x2 muestra un 20. Esto es debido que cuando creamos el objeto prueba2 le pasamos un 20 al constructor e inicializó el atributo estático con dicho valor.
Es muy importante entender que el atributo estático es compartido por todos los objetos que se definan de dicha clase.
Plantear una clase Cuenta que defina dos atributos, uno que almacene el importe de la misma y otro atributo estático llamado cantidad que se debe incrementar en uno cada vez que se crea un objeto de dicha clase. Por otro lado crear una clase Banco que defina tres objetos de la clase Cuenta. Imprimir la cantidad de cuentas accediendo al atributo cantidad de la clase Cuenta.
#include<iostream>
using namespace std;
class Cuenta {
float saldo;
static int cantidad;
public:
Cuenta(float sal) { saldo = sal; cantidad++; };
int retornarCantidad() { return cantidad; };
};
int Cuenta::cantidad = 0;
class Banco {
Cuenta *cuenta1, *cuenta2, *cuenta3;
public:
Banco();
~Banco();
void cantidadClientes();
};
Banco::Banco()
{
cuenta1 = new Cuenta(1000);
cuenta2 = new Cuenta(3000);
cuenta3 = new Cuenta(5000);
}
Banco::~Banco()
{
delete cuenta1;
delete cuenta2;
delete cuenta3;
}
void Banco::cantidadClientes()
{
cout << cuenta1->retornarCantidad();
}
int main()
{
Banco *banco1 = new Banco();
banco1->cantidadClientes();
delete banco1;
return 0;
}
Este proyecto lo puede descargar en un zip desde este enlace : AtributoEstatico2.zip
Declaramos la clase cuenta con sus dos atributos saldo y cantidad. A cantidad la declaramos de tipo static. Tanto al constructor como al método retornanCantidad los hacemos inline (es decir los implementamos en la declaración de la clase):
class Cuenta {
float saldo;
static int cantidad;
public:
Cuenta(float sal) { saldo = sal; cantidad++; };
int retornarCantidad() { return cantidad; };
};
Como vemos en el constructor inicializamos el atributo saldo con el parámetro sal e incrementamos en 1 el atributo estático cantidad (cada vez que se ejecute este constructor para cada uno de los objetos que creamos de esta clase el atributo cantidad se incrementa en uno).
Fuera de la clase definimos el atributo estático cantidad que pertenece a la clase Cuenta que es de tipo int y lo inicializamos con el valor 0:
int Cuenta::cantidad = 0;
Seguidamente declaramos la clase Banco y definimos tres objetos de la clase Cuenta:
class Banco {
Cuenta *cuenta1, *cuenta2, *cuenta3;
public:
Banco();
~Banco();
void cantidadClientes();
};
En el constructor creamos los tres objetos y en el destructor liberamos el espacio de dichos objetos:
Banco::Banco()
{
cuenta1 = new Cuenta(1000);
cuenta2 = new Cuenta(3000);
cuenta3 = new Cuenta(5000);
}
Banco::~Banco()
{
delete cuenta1;
delete cuenta2;
delete cuenta3;
}
Si queremos saber la cantidad de cuentas que tiene el banco tenemos que acceder al atributo cantidad de la clase Cuenta. Llamamos en este caso al método retornarCantidad() de la clase Cuenta que retorna el valor del atributo estático cantidad:
void Banco::cantidadClientes()
{
cout << cuenta1->retornarCantidad();
}
Si bien la llamada al método retornarCantidad() lo hicimos a través del objeto cuenta1 el resultado hubiera sido el mismo si lo llamamos por medio de alguno de los otros dos objetos: cuenta2 o cuenta3.
En la main Creamos un objeto de la clase Banco:
int main()
{
Banco *banco1 = new Banco();
banco1->cantidadClientes();
delete banco1;
return 0;
}