Variable estática C ++
Ejemplo 1
Veamos esta primera instancia de una variable estática en C++.
#incluir#incluir
usando el espacio de nombres STD;
void my_demo ()
static int count_val = 0;
cout<
int main ()
para (int i = 0; i<4; i++)
My_demo ();
regresar 0;
Dentro de la función "my_demo", hemos creado la variable estática "count_val" utilizando la palabra clave estática y configurando con el valor cero. Después de eso, el count_val se incrementa para la siguiente llamada de función. Luego, tenemos la función principal donde tenemos un bucle for para iteración e invocamos la función "my_demo".
El resultado del script de variable estática anterior es el siguiente:
Ejemplo 2
Las variables estáticas en una clase son accesibles por los objetos, ya que se asignan espacio en un almacenamiento estático separado, lo que significa que las variables marcadas como estáticas se inicializan solo una vez. Las mismas variables estáticas no se pueden usar más de una vez para diferentes objetos. Además, debido a esto, los constructores no pueden inicializar variables estáticas. Como resultado, el usuario necesita inicializar manualmente las variables estáticas dentro de las clases utilizando el nombre de clase y el operador de resolución de alcance más allá de la clase, como se ilustra a continuación:
#incluirusando el espacio de nombres STD;
Clase MyClass
público:
static int x;
Mi clase()
// Cuerpo vacío
;
;
int myClass :: x = 2;
int main ()
Myclassobj;
cout<
Hemos establecido una clase, "MyClass", que se mantiene pública. Luego, hemos definido una variable estática "x". Luego, creamos el constructor de la clase "MyClass", que no hace nada debido a su cuerpo vacío. Fuera de la clase, hemos inicializado explícitamente la variable estática "X" con la resolución de alcance "::". Luego, dentro del int Main, hemos declarado el objeto "obj" invocando el "myclass" e imprimiendo su valor.
El valor de la variable estática x establecida en el script anterior se muestra a continuación.
Ejemplo 3
Como puede ver en el programa anterior, hicimos un esfuerzo por hacer varios duplicados de la variable estática para varios objetos. Pero esto no tuvo lugar.
#incluirusando el espacio de nombres STD;
clase myclass2
int a;
público:
MyClass2 ()
a = 0;
cout<< " Constructor Body\n";
~ MyClass2 ()
cout<< "Destructor Body\n";
;
int main ()
int b = 0;
if (b == 0)
MyClass2 obj;
cout<< "Main Terminated\n";
Hemos establecido una clase, "myclass2", y declaramos un objeto como "a". Luego, hemos definido el constructor de "MyClass2", que inicializa el objeto "A" con el valor cero. Además, convencerá la declaración "Cuerpo de constructor". Además, hemos construido el destructor de la clase "MyClass2", que solo imprime la declaración "Cuerpo de destructor". Después de eso, hemos creado la función principal int, que define e inicializa otro objeto como "B" establecido como cero. Además, tenemos una declaración IF que tiene la condición de que el objeto "B" sea igual al valor cero y luego define el Constructor MyClass2 Object como "OBJ". Al final, hemos llamado al comando Cout, que imprimirá el mensaje del principal terminado.
El siguiente resultado se imprime en el aviso.
Ejemplo 4
El objeto se designa como no estático en los programas mencionados anteriormente si bloquea. Por lo tanto, el alcance de la variable está restringido al bloque if. Como resultado, el constructor de la función se llama cuando se crea un objeto, y el destructor se llama tan pronto como el control de Bloque IF ya no está vigente porque el alcance de un objeto se limita al bloque if, donde se declara. Ahora examinemos cómo cambiará la salida si declaramos que el objeto es estático.
#incluirusando el espacio de nombres STD;
clase myClass3
int x = 0;
público:
MyClass3 ()
x = 0;
cout<< "Constructor Section\n";
~ MyClass3 ()
cout<< "Destructor Section\n";
;
int main ()
int y = 0;
if (y == 0)
MyClass3 estático obj;
cout<< "Main Ended\n";
Hemos creado la clase "myclas3" como en el programa anterior. Luego, definimos la variable x y le asignamos un valor de cero. El constructor y el destructor también se establecen dentro de la clase "myclass3". Dentro de la declaración principal, si es condicional, hemos declarado el objeto estático de "myclass3".
El cambio en el rendimiento es obvio. Debido a que se llama al destructor en la pantalla rápida posterior después de la principal, esto tuvo lugar como resultado de que la vida útil del programa sea cubierta por objetos estáticos.
Ejemplo 5
La existencia de funciones de miembros estáticos dentro de una clase es independiente de cualquier objeto de clase, al igual que la de los miembros de los datos estáticos o las variables estáticas. En contraste con los miembros de datos no estáticos de la clase y las funciones de los miembros, las funciones de los miembros estáticos solo tienen acceso a otras funciones de miembros estáticos u otros miembros de datos estáticos.
#incluirusando el espacio de nombres STD;
Clase New_Class
público:
static void display_msg ()
cout<<"Welcome to my portal";
;
int main ()
New_class :: display_msg ();
La clase "new_class" tiene un modificador público que define la función de miembro void estático como "display_msg". Dentro de esa función de miembro estático "Display_MSG", hemos impreso la instrucción Cout. Fuera del "new_class", tenemos el método principal del programa donde hemos invocado la función de miembro estático "display_msg".
La salida imprime el mensaje dentro de la función de miembro estático "display_msg" de la siguiente manera:
Conclusión
Nuestra comprensión de la idea estática en C ++ puede basarse en el artículo antes mencionado. En el área de almacenamiento estático, los artículos estáticos solo se asignan almacenamiento una vez durante un programa. Además, son válidos para todo el período del programa. Esta guía analiza las diversas técnicas de uso estático junto con ejemplos de trabajo. El uso de los conceptos de acuerdo con las necesidades del programador será más fácil con la ayuda de los ejemplos.