Las reglas son las mismas para objetos estáticos de tipos definidos por el usuario, añadiendo el hecho que el objeto requiere ser inicializado. Sin embargo, la asignación del valor cero sólo tiene sentido para tipos predefinidos. Los tipos definidos por el usuario deben ser inicializados llamando a sus respectivos constructores. Por tanto, si no especifica argumentos en los constructores cuando defina un objeto estático, la clase deberá tener un constructor por defecto. Por ejemplo:

//: C10:StaticObjectsInFunctions.cpp
#include <iostream>
using namespace std;

class X {
  int i;
public:
  X(int ii = 0) : i(ii) {} // Default
  ~X() { cout << "X::~X()" << endl; }
};

void f() {
  static X x1(47);
  static X x2; // Default constructor required
}

int main() {
  f();
} ///:~

Los objetos estáticos de tipo X dentro de f() pueden ser inicializados tanto con la lista de argumentos del constructor como con el constructor por defecto. Esta construcción ocurre únicamente la primera vez que el control llega a la definición.

Los destructores para objetos estáticos (es decir, cualquier objeto con almacenamiento estático, no sólo objetos estáticos locales como en el ejemplo anterior) son invocados cuando main() finaliza o cuando la función de librería estándar de C exit() se llama explícitamente. En la mayoría de implementaciones, main() simplemente llama a exit() cuando termina. Esto significa que puede ser peligroso llamar a exit() dentro de un destructor porque podría producirse una invocación recursiva infinita. Los destructores de objetos estáticos no se invocan si se sale del programa utilizando la función de librería estándar de C abort().

Es posible especificar acciones que se lleven a cabo tras finalizar la ejecución de main() (o llamando a exit()) utilizando la función de librería estándar de C atexit(). En este caso, las funciones registradas en atexit() serán invocadas antes de los destructores para cualquier objeto construido antes de abandonar main() (o de llamar a exit()).

Como la destrucción ordinaria, la destrucción de objetos estáticos se lleva a cabo en orden inverso al de la inicialización. Hay que tener en cuenta que sólo los objetos que han sido construidos serán destruidos. Afortunadamente, las herramientas de desarrollo de C++ mantienen un registro del orden de inicialización y de los objetos que han sido construidos. Los objetos globales siempre se construyen antes de entrar en main() y se destruyen una vez se sale, pero si existe una función que contiene un objeto local estático a la que nunca se llama, el constructor de dicho objeto nunca fue ejecutado y, por tanto, nunca se invocará su destructor. Por ejemplo:

//: C10:StaticDestructors.cpp
// Static object destructors
#include <fstream>
using namespace std;
ofstream out("statdest.out"); // Trace file

class Obj {
  char c; // Identifier
public:
  Obj(char cc) : c(cc) {
    out << "Obj::Obj() for " << c << endl;
  }
  ~Obj() {
    out << "Obj::~Obj() for " << c << endl;
  }
};

Obj a('a'); // Global (static storage)
// Constructor & destructor always called

void f() {
  static Obj b('b');
}

void g() {
  static Obj c('c');
}

int main() {
  out << "inside main()" << endl;
  f(); // Calls static constructor for b
  // g() not called
  out << "leaving main()" << endl;
} ///:~

En Obj, char c actúa como un identificador de forma que el constructor y el destructor pueden imprimir la información acerca del objeto sobre el que actúan. Obj a es un objeto global y por tanto su constructor siempre se llama antes de que el control pase a main(), pero el constructor para static Obj b dentro de f(), y el de static Obj c dentro de g() sólo serán invocados si se llama a esas funciones.

Para mostrar qué constructores y qué destructores serán llamados, sólo se invoca a f(). La salida del programa será la siguiente:

Obj::Obj() for a
inside main()
Obj::Obj() for b
leaving main()
Obj::~Obj() for b
Obj::~Obj() for a

El constructor para a se invoca antes de entrar en main() y el constructor de b se invoca sólo porque existe una llamada a f(). Cuando se sale de main(), se invoca a los destructores de los objetos que han sido construidos en orden inverso al de su construcción. Esto significa que si llama a g(), el orden en el que los destructores para b y c son invocados depende de si se llamó primero a f() o a g().

Nótese que el objeto out de tipo ofstream, utilizado en la gestión de ficheros, también es un objeto estático (puesto que está definido fuera de cualquier función, reside en el área de almacenamiento estático). Es importante remarcar que su definición (a diferencia de una declaración tipo extern) aparece al principio del fichero, antes de cualquier posible uso de out. De lo contrario estaríamos utilizando un objeto antes de que estuviese adecuadamente inicializado.

En C++, el constructor de un objeto estático global se invoca antes de entrar en main(), de forma que ya dispone de una forma simple y portable de ejecutar código antes de entrar en main(), así como ejecutar código después de salir de main(). En C, eso siempre implicaba revolver el código ensamblador de arranque del compilador utilizado.

He aquí un ejemplo de cómo los dos significados de static pueden confundirse. Todos los objetos globales tienen implícitamente almacenamiento de tipo estático, o sea que si usted dice (en ámbito de fichero)

int a = 0;

el almacenamiento para a se llevará a cabo en el área para datos estáticos del programa y la inicialización para a sólo se realizará una vez, antes de entrar en main(). Además, la visibilidad de a es global para todas las unidades de traducción. En términos de visibilidad, lo opuesto a static (visible tan sólo en su :unidad de traducción) es extern que establece explícitamente que la visibilidad del nombre se extienda a todas las unidades de traducción. Es decir, la definición de arriba equivale a

extern int a = 0;

Pero si utilizase

static int a = 0;

todo lo que habría hecho es cambiar la visibilidad, de forma que a tiene enlace interno. El tipo de almacenamiento no se altera, el objeto reside en el área de datos estática aunque en este caso su visibilidad es static y en el otro es extern.

Cuando pasamos a hablar de variables locales, static deja de alterar la visibilidad y pasa a alterar el tipo de almacenamiento.

Si declara lo que parece ser una variable local como extern, significa que el almacenamiento existe en alguna otra parte (y por tanto la variable realmente es global a la función). Por ejemplo:

//: C10:LocalExtern.cpp
//{L} LocalExtern2
#include <iostream>

int main() {
  extern int i;
  std::cout << i;
} ///:~

Para nombres de funciones (sin tener en cuenta las funciones miembro), static y extern sólo pueden alterar la visibilidad, de forma que si escribe

extern void f();

es lo mismo que la menos adornada declaración

void f();

y si utiliza

static void f();

significa que f() es visible sólo para la unidad de traducción, (esto suele llamarse estático a fichero (file static).