¿Cuándo usar la palabra clave “estática” en la clase C ++?

Question

Código

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

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

¿En qué condición debemos usar la estática en clase?

Answer 1

Hay tres lugares donde se puede usar la palabra clave static. Uno está en la declaración de una estructura / clase cuando ese contexto significa que el método es un método de clase en lugar de un método de instancia. Esto significa que este método se llama directamente y no necesita una instancia. Desde este método estático, no puede acceder a las variables de instancia.

En MyClass.h

struct MyClass
{
  static void ThreadEntryStatic();

  void Begin();
};

En MyClass.cpp

void MyClass::ThreadEntryStatic()
{
}

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

Un segundo caso en el que se usa la palabra clave estática está en el alcance de un archivo en el que no desea que la visibilidad de la variable declarada sea visible fuera del archivo. También puede usar un espacio de nombres anónimo para esto también.

Un tercer caso donde se usa la palabra clave estática está en el alcance de un método y el valor se retiene entre las ejecuciones de la función (y se inicializa con la asignación la primera vez).

Answer 2

Si está ejecutando métodos estáticos en varios subprocesos, debe prestar mucha atención a la sincronización de su código. En mi opinión, al realizar una programación multiproceso, trato de usar una instancia separada de mi objeto o elemento de trabajo por subproceso y evito cualquier tipo de datos estáticos o compartidos. Por supuesto, esto no siempre es posible, por lo que el subprocesamiento sigue siendo una de las áreas de programación más difíciles de tratar.

Answer 3

Como ejemplo concreto,

class Test{
      static void foo();      
};

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

no se va a compilar, no puede declarar una función con una palabra clave estática fuera de la declaración de clase. Simplemente tiene que eliminar la palabra clave estática cuando está implementando la función.

class Test{
      static void foo();      
};

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

Answer 4

Algunas personas se han referido a esto, pero static utilizado para la vinculación interna no debe utilizarse, en su lugar, debe usarse un espacio de nombres anónimo:

namespace
{

void myInternallyLinkedFunction()
{
    // do something
}

int myInternallyLinkedInteger;

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

} // anon namespace


void myExternallyLinkedFunction()
{

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

Answer 5

El valor de las variables estáticas se conserva entre las llamadas de función. Consulte esta entrada de MSDN para ver ejemplos. Definir y utilizar " static " Los métodos han sido descritos en la respuesta de Chrish

Se puede usar estática al implementar clases singleton en las que necesitas tener solo una instancia de la clase. Su uso depende del contexto.

Answer 6

Lo que muestra su ejemplo es una devolución de llamada de subproceso de función de miembro estático " modelo. Como la función de subproceso debe tener una firma WINAPI, no puede ser una función miembro normal, solo un miembro estático. A menudo, pasa esto como un parámetro de hilo a esta devolución de llamada y luego llama a un miembro real que realiza el trabajo del hilo.

Hay un solo uso de un miembro estático, y hay muchos diferentes. Es realmente difícil adivinar cuál es el propósito de su pregunta. ¿Está solucionando algún problema en particular o está interesado en todos los usos posibles de los miembros estáticos o las funciones de los miembros estáticos?

Ejemplo más completo de " devolución de llamada del subproceso de función de miembro estático " ;:

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

};