Utilice la palabra clave estática en C++

1. Utilice la palabra clave static para declarar variables con duración estática en C++
2. Utilice la palabra clave static para declarar miembros estáticos de una clase en C++

Esta guía explicará varios métodos de cómo utilizar la palabra clave static en C++.

Utilice la palabra clave static para declarar variables con duración estática en C++

La palabra clave static se puede utilizar para declarar variables locales con duración estática. Al contrario de lo que podría sugerir el nombre, una variable local con duración estática implica que su valor permanece activo en la memoria incluso después de que el bloque, donde se declara la variable, salga del alcance.

Básicamente, estas variables locales pueden tener sus valores guardados entre las llamadas de función donde están definidas. Observe que la función incrementCount tiene una variable llamada count, que se inicializa con el valor de 0. El atributo count se asigna en la región de memoria que está activa hasta que finaliza el programa. Por lo tanto, cada llamada a incrementCount agrega una sola unidad al entero dado.

#include <iostream>

using std::cout;
using std::endl;

int incrementCount() {
  static int count = 0;
  return ++count;
}

int main() {
  for (int i = 0; i < 20; ++i) {
    if (i % 2 == 0) incrementCount();
  }
  cout << incrementCount() - 1 << endl;

  return EXIT_SUCCESS;
}

Producción :

10

Utilice la palabra clave static para declarar miembros estáticos de una clase en C++

Por otro lado, la palabra clave static se utiliza para declarar miembros de datos estáticos de la clase. Estos miembros están asociados con el tipo de clase en sí en lugar de las instancias particulares de la clase. Entonces, si definimos un miembro de datos estáticos para una clase determinada, cada instancia de este tipo de clase tendrá el mismo valor para el miembro de datos. A diferencia de tener un miembro privado, el primero tendrá una única copia en la memoria. La última característica hace que los miembros de datos estáticos sean eficientes desde el punto de vista de la huella de memoria de clase.

Los miembros de datos estáticos se definen e inicializan de forma diferente a los miembros de datos normales. Los miembros estáticos deben declararse dentro de la clase y definirse fuera de la clase en el archivo fuente asociado. La palabra clave static solo se usa en la declaración dentro de la clase. Los constructores no pueden inicializar ninguno de los miembros de datos estáticos, y no pueden inicializarse dentro del cuerpo de la clase a menos que tengan un tipo integral const. Los últimos tipos aún deben definirse fuera del cuerpo de la clase sin una especificación de valor inicial. El siguiente ejemplo demuestra el uso simple del miembro de datos static name, que se inicializa con el literal de cadena y luego se modifica con la función setNewName.

#include <iostream>
#include <string>
#include <utility>

using std::cin;
using std::cout;
using std::endl;
using std::string;

class MyClass1 {
 private:
  static string name;
  string nickname;

 public:
  explicit MyClass1(string n) : nickname(std::move(n)){};

  static string getName() { return name; }
  static void setNewName(std::basic_string<char> s) { name = std::move(s); }
  string getNickname() { return nickname; }

  ~MyClass1() = default;
};

string MyClass1::name = "Static name";

int main() {
  MyClass1 m1(string("April"));
  MyClass1 m2(string("Maude"));

  cout << MyClass1::getName() << endl;
  MyClass1::setNewName("New name");
  cout << MyClass1::getName() << endl;

  return EXIT_SUCCESS;
}

Producción :

Static name
New name

Alternativamente, la clase puede tener los miembros de la función static que no están vinculados a ningún objeto y, por lo tanto, no pueden referirse al objeto this en sus cuerpos. Generalmente, estas funciones no necesitan tener una declaración y una definición separadas similares a los miembros de datos estáticos, como se muestra en el siguiente programa de ejemplo. Aún así, la mayoría de las guías de estilo contemporáneas generalmente requerirán que el programador desacople las dos.

#include <iostream>
#include <string>
#include <utility>

using std::cin;
using std::cout;
using std::endl;
using std::string;

class MyClass1 {
 private:
  static string name;
  string nickname;

 public:
  explicit MyClass1(string n) : nickname(std::move(n)){};

  static string getName() { return name; }
  static void setNewName(std::basic_string<char> s) { name = std::move(s); }
  string getNickname() { return nickname; }

  static bool compareStrings(const std::basic_string<char>& s1,
                             const std::basic_string<char>& s2) {
    if (s1 == s2)
      return true;
    else
      return false;
  }

  ~MyClass1() = default;
};

string MyClass1::name = "Static name";

int main() {
  MyClass1 m1(string("April"));
  MyClass1 m2(string("Maude"));

  MyClass1::compareStrings(m1.getNickname(), m2.getNickname())
      ? cout << "strings are equal" << endl
      : cout << "strings are not equal" << endl;

  MyClass1::compareStrings(MyClass1::getName(), MyClass1::getName())
      ? cout << "strings are equal" << endl
      : cout << "strings are not equal" << endl;

  return EXIT_SUCCESS;
}

Producción :

strings are not equal
strings are equal