Initialiser partiellement la variable définie dans l'autre module

Question

Je considère une certaine solution où je voudrais initialiser une cellule d'un tableau qui est définie dans un autre module (il y aura beaucoup de modules initialisant une table). Le tableau ne sera pas lu avant l'exécution de main (donc il n'y a pas de problème avec l'ordre d'initialisation statique).

Mon approche:

/* secondary module */ 

extern int i[10]; // the array 

const struct Initialize { 
    Initialize() { i[0] = 12345; } 
} init; 

/* main module */ 

#include <stdio.h> 


int i[10]; 

int main() 
{ 
    printf("%d\n", i[0]); // check if the value is initialized 
} 

compilateur ne supprimera pas à init constante parce que le constructeur a des effets secondaires. Ai-je raison? Est-ce que le mécanisme est OK? Sur GCC (-O3) tout va bien.

// EDIT
Dans un monde réel, il y aura beaucoup de modules. Je veux éviter un module supplémentaire, une place centrale qui rassemblera toutes les routines d'initialisation mineures (pour une meilleure évolutivité). Il est donc important que chaque module déclenche sa propre initialisation.

Answer 1

Cela fonctionne avec les compilateurs MSVC mais pas avec GNU C++ (au moins pour moi). L'éditeur de liens GNU supprimera tout le symbole non utilisé en dehors de votre unité de compilation. Je ne connais qu'une seule façon de garantir une telle initialisation - "id once" idiome. Pour examle:

init_once.h:

template <typename T> 
class InitOnce 
{ 
    T *instance; 
    static unsigned refs; 
public: 
    InitOnce() { 
     if (!refs++) { 
      instance = new T(); 
     } 
    } 

    ~InitOnce() { 
     if (!--refs) { 
      delete instance; 
     } 
    } 
}; 
template <typename T> unsigned InitOnce<T>::refs(0); 

unit.h:

#include "init_once.h" 

class Init : public InitOnce<Init> 
{ 
public: 
    Init(); 
    ~Init(); 
}; 
static Init module_init_; 

secondary.cpp:

#include "unit.h" 
extern int i[10]; // the array 

Init::Init() 
{ 
    i[0] = 12345; 
} 
... 

Answer 2

EDIT

/*secondary module (secondary.cpp) */ 

    int i[10]; 
    void func() 
    { 
     i[0]=1; 

    } 

.

/*main module (main.cpp)*/ 

    #include<iostream> 

    extern int i[]; 
    void func(); 
    int main() 
    { 
    func(); 
    std::cout<<i[0]; //prints 1 
    } 

Compile, lien et créer et exécutable en utilisant g++ secondary.cpp main.cpp -o myfile

En général les constructeurs sont utilisés (et doivent être utilisés) pour initialiser les membres d'une seule classe.

Answer 3

Je ne pense pas que vous voulez le extern int i[10]; dans votre module principal, cependant, adf88.

Answer 4

Cela peut fonctionner, mais c'est dangereux. L'ordre de construction global/statique dans un seul module n'est pas défini, tout comme l'ordre de chargement du module (à moins que vous ne le gériez explicitement). Par exemple, vous supposez que lors de l'initialisation de secondary.c(), ctor run, i est déjà présent. Vous devez faire très attention de ne pas avoir deux modules initialisant les mêmes données communes, ou avoir deux modules effectuant des initialisations avec des effets secondaires qui se chevauchent.

Je pense qu'une conception plus propre pour répondre à un tel besoin est d'avoir le propriétaire des données communes (votre module principal) l'exposer comme un singleton global, avec une interface pour effectuer toutes les initialisations de données nécessaires. Vous disposez d'un emplacement central pour contrôler l'ordre d'initialisation, et peut-être même contrôler l'accès simultané (en utilisant des sections critiques ou d'autres primitives de concurrence). Le long des lignes de votre exemple simplifié, qui pourrait être -

/module principal (main.c)/

#include classe CommonDat {int i ;

public: 
    const int GetI() { return i;} 
    void SetI(int newI) { i = newI; } 
    void incI()   
    { 
     AcquireSomeLock(); 
     i++; 
     ReleaseTheLock(); 
    } 
} 

CommonDat g_CommonDat; 
CommonDat* getCommonDat() { return &g_CommonDat; } 

int main(void) 
{ 
    printf("%d",getCommonDat()->GetI()); 
} 

Il est également préférable d'avoir les modules secondaires appellent ces interfaces parfois contrôlées dans l'exécution (et non pendant les c'tors mondiales passe).

(REMARQUE: vous avez nommé les fichiers en tant que fichiers C, mais étiqueté la question en tant que C++. Le code suggéré est C++, bien sûr).

Answer 5

Puis-je demander pourquoi vous utilisez un tableau (en cours d'exécution le risque de sortir des limites) quand vous pourriez utiliser un std::vector?

std::vector<int>& globalArray() 
{ 
    static std::vector<int> V; 
    return V; 
} 

bool const push_back(std::vector<int>& vec, int v) 
{ 
    vec.push_back(v); 
    return true; // dummy return for static init 
} 

Ce tableau est initialisé paresseusement lors du premier appel à la fonction.

Vous pouvez l'utiliser comme tel:

// module1.cpp 
static bool const dummy = push_back(globalArray(), 1); 

// module2.cpp 
static bool const dummy = push_back(globalArray(), 2); 

Il semble beaucoup plus facile et moins sujette aux erreurs. Ce n'est pas compatible avec le multithread jusqu'à C++ 0x cependant.