Utiliser le mot-clé statique en C++

1. Utilisez le mot-clé static pour déclarer des variables avec une durée statique en C++
2. Utilisez le mot-clé static pour déclarer les membres statiques de la classe en C++

Ce guide expliquera plusieurs méthodes d’utilisation du mot-clé static en C++.

Utilisez le mot-clé static pour déclarer des variables avec une durée statique en C++

Le mot clé static permet de déclarer des variables locales de durée statique. Contrairement à ce que le nommage pourrait suggérer, une variable locale avec une durée statique implique que sa valeur reste active dans la mémoire même après que le bloc, où la variable est déclarée, soit hors de portée.

Fondamentalement, ces variables locales peuvent avoir leurs valeurs enregistrées entre les appels de fonction où elles sont définies. Notez que la fonction incrementCount possède une variable appelée count, qui est initialisée avec la valeur 0. L’attribut count est alloué dans la région de mémoire qui est active jusqu’à la fin du programme. Ainsi, chaque appel à incrementCount ajoute une seule unité à l’entier donné.

#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;
}

Production:

10

Utilisez le mot-clé static pour déclarer les membres statiques de la classe en C++

D’autre part, le mot-clé static est utilisé pour déclarer les données membres statiques de la classe. Ces membres sont associés au type de classe lui-même plutôt qu’aux instances particulières de la classe. Ainsi, si nous définissons une donnée membre statique pour une classe donnée, chaque instance de ce type de classe aura la même valeur pour la donnée membre. Contrairement à un simple membre, le premier n’aura qu’un seul exemplaire en mémoire. Cette dernière fonctionnalité rend les membres de données statiques efficaces du point de vue de l’empreinte mémoire de la classe.

Les membres de données static sont définis et initialisés différemment des membres de données ordinaires. Les membres static doivent être déclarés à l’intérieur de la classe et définis à l’extérieur de la classe dans le fichier source associé. Le mot clé static n’est utilisé que dans la déclaration à l’intérieur de la classe. Aucune des données membres statiques ne peut être initialisée par les constructeurs, et elles ne peuvent pas être initialisées à l’intérieur du corps de la classe à moins qu’elles n’aient un type intégral const. Ces derniers types doivent encore être définis en dehors du corps de la classe sans spécification de valeur initiale. L’exemple suivant montre l’utilisation simple du membre de données static na static est initialisé avec le littéral de chaîne et est ensuite modifié avec la fonction 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;
}

Production:

Static name New name

Alternativement, la classe peut avoir les membres de fonction static qui ne sont liés à aucun objet, et donc ils ne peuvent pas faire référence à l’objet this dans leurs corps. Généralement, ces fonctions n’ont pas besoin d’avoir une déclaration et une définition séparées similaires aux membres de données static, comme le montre l’exemple de programme suivant. Pourtant, la plupart des guides de style contemporains exigent généralement que le programmeur découple les deux.

#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;
}

Production:

strings are not equal strings are equal