Quand utiliser le mot clé & # 8220; statique & # 8221; en classe C ++?

Question

Code

 static void MyClass::ThreadEntryStatic()
 {
    //...
 }

 void MyClass::Begin()
 {
         CreateThread(..,ThreadEntryStatic,..);
 }

Dans quelles conditions utiliser le static en classe?

Answer 1

Le mot clé static peut être utilisé à trois endroits. On est dans la déclaration d'une struct / class lorsque ce contexte signifie que la méthode est une méthode de classe au lieu d'une méthode d'instance. Cela signifie que cette méthode est appelée directement et que vous n'avez pas besoin d'instance. À partir de cette méthode statique, vous ne pouvez pas accéder aux variables d'instance.

Dans MyClass.h

struct MyClass
{
  static void ThreadEntryStatic();

  void Begin();
};

Dans MyClass.cpp

void MyClass::ThreadEntryStatic()
{
}

void MyClass::Begin()
{
  CreateThread(.., MyClass::ThreadEntryStatic, ...);
}

Un deuxième cas d'utilisation du mot-clé static concerne un fichier dans lequel vous ne souhaitez pas que la visibilité de la variable déclarée soit visible en dehors du fichier. Vous pouvez également utiliser un espace de noms anonyme pour cela également.

Un troisième cas d'utilisation du mot-clé static est dans le cadre d'une méthode et la valeur est conservée entre les exécutions de la fonction (et initialisée avec l'affectation la première fois).

Answer 2

Si vous exécutez des méthodes statiques sur plusieurs threads, vous devez porter une attention particulière à la synchronisation de votre code. À mon avis, lors de la programmation multithread, j'essaie d'utiliser une instance distincte de mon objet ou de mon élément de travail par thread et d'éviter tout type de données statiques ou partagées. Bien sûr, cela n’est pas toujours possible. Le threading reste donc l’un des domaines de programmation les plus délicats à traiter.

Answer 3

À titre d'exemple concret,

class Test{
      static void foo();      
};

static void Test::foo(){
    // code here
}

ne va pas compiler, vous ne pouvez pas déclarer une fonction avec un mot clé static en dehors de la déclaration de la classe. Vous devez simplement supprimer le mot clé static lorsque vous implémentez la fonction.

class Test{
      static void foo();      
};

void Test::foo(){
    // code here
}

Answer 4

Quelques personnes ont abordé ce sujet, mais static utilisé pour la liaison interne ne doit pas être utilisé, mais un espace de nom anonyme:

namespace
{

void myInternallyLinkedFunction()
{
    // do something
}

int myInternallyLinkedInteger;

class myInternallyLinkedClass
{
public:
    void doSomething();
};

} // anon namespace


void myExternallyLinkedFunction()
{

    ++myInternallyLinkedInteger;
    myInternallyLinkedFunction();
    myInternallyLinkedClass x;
    x.doSomething();
}

Answer 5

La valeur des variables statiques est conservée entre les appels de fonction. Vérifiez cette entrée MSDN pour obtenir des exemples. Définir et utiliser " statique " méthodes a été décrite dans la réponse de chrish

Static peut être utilisé lors de l'implémentation de classes singleton où vous devez n'avoir qu'une seule instance de la classe. Son utilisation dépend du contexte.

Answer 6

Ce que votre exemple montre est un "rappel de thread de fonction de membre statique" " modèle. Comme la fonction de thread doit avoir une signature WINAPI, il ne peut s'agir d'une fonction de membre normale, mais uniquement d'un membre statique. Souvent, vous transmettez ceci en tant que thread parametr à ce rappel, puis appelez un membre réel effectuant le travail du thread.

Un membre statique est utilisé à une seule utilisation et il en existe de nombreuses Il est très difficile de deviner quel est le but de votre question. Résolvez-vous un problème particulier ou êtes-vous simplement intéressé par toutes les utilisations possibles des membres statiques ou des fonctions de membre statique?

Exemple plus complet de "rappel de thread de fonction de membre statique":

class MyClass
{

  /// background rendering thread
  int ThreadEntry()
  {
     // do the work here
  }

  /// static member callback "proxy"
  static DWORD WINAPI ThreadEntryStatic(void *param)
  {
    return ((EngineDD9 *)param)->ThreadEntry();
  }

  void SpawnThread()
  {
    CreateThread(.., ThreadEntryStatic, ...);
  }

};