Quando utilizzare la parola chiave & # 8220; statico & # 8221; in classe C ++?

Question

Codice

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

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

In quale condizione dovremmo usare lo statico in classe?

Answer 1

Esistono tre posizioni in cui è possibile utilizzare la parola chiave static. Uno è nella dichiarazione di una struttura / classe quando quel contesto significa che il metodo è un metodo di classe anziché un metodo di istanza. Ciò significa che questo metodo viene chiamato direttamente e non è necessaria un'istanza. Da questo metodo statico, non è possibile accedere alle variabili di istanza.

In MyClass.h

struct MyClass
{
  static void ThreadEntryStatic();

  void Begin();
};

In MyClass.cpp

void MyClass::ThreadEntryStatic()
{
}

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

Un secondo caso in cui viene utilizzata la parola chiave statica è nell'ambito di un file in cui non si desidera che la visibilità della variabile dichiarata sia visibile all'esterno del file. Puoi anche usare uno spazio dei nomi anonimo anche per questo.

Un terzo caso in cui viene utilizzata la parola chiave statica è nell'ambito di un metodo e il valore viene mantenuto tra le esecuzioni della funzione (e inizializzato con l'assegnazione la prima volta).

Answer 2

Se si stanno eseguendo metodi statici su più thread, è necessario prestare molta attenzione alla sincronizzazione del codice. A mio avviso, quando eseguo la programmazione multithreading, provo a utilizzare un'istanza separata del mio oggetto o oggetto di lavoro per thread, evitando qualsiasi tipo di dati statici o condivisi. Ovviamente questo non è sempre possibile, quindi il threading rimane una delle aree di programmazione più difficili da affrontare.

Answer 3

Come esempio concreto,

class Test{
      static void foo();      
};

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

non verrà compilato, non è possibile dichiarare una funzione con una parola chiave statica al di fuori della dichiarazione di classe. Devi semplicemente rimuovere la parola chiave statica quando stai implementando la funzione.

class Test{
      static void foo();      
};

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

Answer 4

Alcune persone lo hanno toccato, ma statico usato per il collegamento interno non dovrebbe essere usato, invece si dovrebbe usare uno spazio dei nomi anonimo:

namespace
{

void myInternallyLinkedFunction()
{
    // do something
}

int myInternallyLinkedInteger;

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

} // anon namespace


void myExternallyLinkedFunction()
{

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

Answer 5

Il valore delle variabili statiche viene mantenuto tra le chiamate di funzione. Controllare questa voce MSDN per esempi. Definire e utilizzare " statico " i metodi sono stati delineati nella risposta di chrish

È possibile utilizzare statico durante l'implementazione di classi singleton in cui è necessario disporre di una sola istanza della classe. Il suo utilizzo dipende dal contesto.

Answer 6

Ciò che mostra il tuo esempio è un "callback di thread di funzioni membro statico" modello. Poiché la funzione thread deve avere una firma WINAPI, non può essere una normale funzione membro, ma solo un membro statico. Spesso si passa questo parametro come parametro a questo callback e quindi si chiama un membro reale che esegue il lavoro del thread.

C'è solo un uso di un membro statico e ce ne sono molti diversi. È davvero difficile indovinare quale sia lo scopo della tua domanda. Stai risolvendo qualche problema particolare o sei solo interessato a tutti i possibili usi dei membri statici o delle funzioni dei membri statici?

Esempio più completo di " callback thread di funzioni membro statiche " ;:

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, ...);
  }

};