Qu'est-ce qu'un bloc statique en c ou C++?

Question

Je veux savoir ce qu'est un bloc statique en c ou C++ avec un exemple? Je sais ce qui est statique mais quelle est la différence entre un bloc statique et statique?

Answer 1

Une autre alternative est que vous cherchiez peut-être l'analogie d'un bloc statique en Java. Un bloc de code qui est exécuté lorsque l'application est chargée. Il n'existe rien de tel en C++ mais il peut être truqué en utilisant le constructeur d'un objet statique .

foo.cpp: 

struct StaticBlock { 
    StaticBlock(){ 
     cout << "hello" << endl; 
    } 
} 


static StaticBlock staticBlock; 

void main(int, char * args[]){ 

} 

CEPENDANT. J'ai été mordu par cela avant car c'est un cas subtil de la norme C++ . Si l'objet statique n'est pas accessible par un code appelé par le principal, le constructeur de l'objet statique peut ou non être appelé.

J'ai trouvé qu'avec gcc hello obtiendra la sortie et avec le studio visuel ce sera pas.

Answer 2

En C++, il y a le concept d'un espace de noms anonyme.

foo.cpp: 

namespace { 
    int x; 
    int y; 
} 

pour obtenir le même effet en C

foo.cpp: 

static int x; 
static int y; 

En termes simples, le compilateur n'exporte pas des symboles de unités de traduction quand ils sont soit déclarés statiques ou dans un espace de noms anonyme.

Answer 3

Il n'y a pas de concept avec le nom "bloc statique" en C/C++. Java l'a cependant, un "bloc statique" est un bloc de code d'initialisation pour une classe qui s'exécute exactement une fois, avant que la première instance d'une classe soit créée. Le 'truc qui fonctionne exactement une fois' concept de base peut simuler en C/C++ avec une variable statique, par exemple:

int some_function(int a, int b) 
{ 
static bool once=true; 
if (once) 
{ 
    // this code path runs only once in the program's lifetime 
    once=false; 
} 
... 
} 

Ceci est thread-safe cependant pas. Bien fonctionner en présence de plusieurs threads peut être difficile et délicat parfois.

Answer 4

J'ai trouvé this réponse sur The Code Project. Cela implique d'avoir une variable statique supplémentaire, mais je crois que c'est plus fiable que la réponse de bradgonesurfing. Au fond, il est ceci:

class Foo 
{ 
public: 
    static int __st_init; 
private: 
    static int static_init(){ 
     /* do whatever is needed at static init time */ 
     return 42; 
    } 
}; 
int Foo::__st_init = Foo::static_init(); 

Cela signifie aussi que, comme des blocs statiques de Java, vous n'êtes pas obligé d'avoir jamais fait une instance de class Foo, ce qui est utile lorsque la classe peut prendre beaucoup de données, et Il suffit d'appeler automagiquement quelque chose avant de le charger, sans instancier une instance supplémentaire. Vous pouvez tester ce bloc de code exact. Je l'ai juste compilé (avec une petite sortie de static_init(), et ai eu main() print Foo :: __ st_init, juste pour être sûr), et ça a très bien fonctionné.

$g++ -v 

Using built-in specs. 
COLLECT_GCC=g++ 
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/4.6.1/lto-wrapper 
Target: x86_64-linux-gnu 
Configured with: ../src/configure -v --with-pkgversion='Ubuntu/Linaro 4.6.1-9ubuntu3' --with-bugurl=file:///usr/share/doc/gcc-4.6/README.Bugs --enable-languages=c,c++,fortran,objc,obj-c++,go --prefix=/usr --program-suffix=-4.6 --enable-shared --enable-linker-build-id --with-system-zlib --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --with-gxx-include-dir=/usr/include/c++/4.6 --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --enable-plugin --enable-objc-gc --disable-werror --with-arch-32=i686 --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu 
Thread model: posix 
gcc version 4.6.1 (Ubuntu/Linaro 4.6.1-9ubuntu3) 

---

EDIT:

Désolé que ce soit si tard, mais j'ai testé ce bradgonesurfing mentionné:

Si vous testez mon accès à la variable principale « juste pour faire Bien sûr, " vous vous assurez que la variable est accessible et donc la variable sera initialisée et ainsi static_init sera appelée. Etes-vous sûr qu'il exécute si vous n'imprimer Foo :: __ st_init

je l'intérieur main.cpp suivant:

#include <iostream> 

using namespace std; 

class Foo 
{ 
public: 
    static int __st_init; 
private: 
    static int static_init(){ 
     /* do whatever is needed at static init time */ 
     cout << "Hello, World!"; 
     return 42; 
    } 
}; 
int Foo::__st_init = Foo::static_init(); 

int main(int argc, char** argv) 
{ 
     return 0; 
} 

Je compilé avec g++ ./main.cpp -o main et couru et avons reçu un match amical « Bonjour, Monde!" message sur ma console. Juste pour être complet, j'ai également compilé la même version mais sans l'impression et compilé avec g++ ./main.cpp -g -o main. Je puis a couru l'exécutable avec gdb et a le résultat suivant:

(gdb) break Foo::static_init 
Breakpoint 1 at 0x400740: file ./main.cpp, line 12. 
(gdb) start 
Temporary breakpoint 2 at 0x4006d8: file ./main.cpp, line 19. 
Starting program: /home/caleb/Development/test/main-c++ 

Breakpoint 1, Foo::static_init() at ./main.cpp:12 
12    return 42; 
(gdb) 

Voici une sortie de version plus récente pour g ++: g++ (Ubuntu 4.8.2-19ubuntu1) 4.8.2

Answer 5

Alors en effet, C++ ne dispose pas de blocs statiques dans le cadre de la langue, vous peut mettre en œuvre des blocs statiques sans vous (en tant qu'utilisateur) avoir à utiliser des classes ou des espaces de noms, et peut écrire:

#include "static_block.h" 

static_block { 
    int x = 1; 
    int y = 2; 
    int z = x+y; 
    std::cout << z << " = " << x " << " + " << y << "\n"; 
} 

ou tout ce que vous voulez. Vous ne pouvez pas les avoir dans les classes, cependant, juste au niveau de la portée du fichier. Voir une description détaillée de ceux-ci dans mon answer à une question connexe, et le code pour static_block.hhere.

Remarque: Cela ne nécessite pas C++ 11 et fonctionnera bien avec les anciens compilateurs.