Pourquoi l'initialisation de données à l'échelle globale en les transmettant à certaines fonctions n'est pas possible?

Question

Je me demandais depuis un moment pourquoi l'initialisation de données en les transmettant à une fonction n'est pas permise malgré le fait que les constructeurs qui sont une sorte de fonction puissent être appelés à l'échelle globale, donc si nous avons quelque chose comme un tableau à portée mondiale, il ne peut pas être initialisé par une fonction, mais si elle était un objet d'une structure à portée mondiale, alors il pourrait être initialisé à l'aide d'un constructeur à la portée:

//global scope 

    char charArray[100];//can't be initialized using any function at global scope but in other scopes it could by being passed to some function 

    struct Test{ 
    public: 
     Test(){ 
     //initialization 
     } 
     char charArray[100]; 
    }; 
    Test obj();//now charArray can be initialized using constructor at global scope 

Answer 1

en fait, vous pouvez appeler des fonctions à portée mondiale.

int foo() 
{ 
    return 5; 
} 

int bar = foo(); 

C est la façon dont C a été conçu il y a des années que vous ne pouvez pas faire fonctionner des fonctions de façon autonome. Tout le code du programme commence à main. En général, moins vous dépendez de l'initialisation globale (évitez-la si possible), moins vous aurez à vous inquiéter des erreurs statiques bizarres et de tels problèmes surgissant de manière aléatoire.

Les tableaux sont un cas différent car vous ne pouvez jamais affecter le résultat d'un appel de fonction à un tableau - la seule façon de l'initialiser dans ce cas est dans un constructeur comme vous l'avez observé.

EDIT: approche un peu de mal à initialiser un tableau inspiré par un commentaire:

bool do_init(int a[50]) 
{ 
    // Do whatever to init the array here. 
    return true; 
} 

int array[50]; 
bool init_array = do_init(array); 

Cela ne fonctionne que depuis l'intérieur d'une unité de traduction de l'ordre de la création/l'initialisation de GLOBALS est garanti l'ordre dans lequel ils apparaissent dans le fichier.

Answer 2

Les tableaux ne peuvent pas être directement initialisés avec le résultat d'un appel de fonction, car les tableaux ne peuvent pas être affectés. Toutefois, vous pouvez "initialiser" le tableau si vous conservez ces deux ensembles.

#include <cstdio> 
#include <cstring> 

bool init(char* arr) 
{ 
    strcpy(arr, "Hello"); 
    return true; 
} 

char arr[100]; 
bool dummy = init(arr); 

int main() 
{ 
    puts(arr); 
} 

Et puis, un tableau peut être enveloppé dans un objet.

#include <array> 
#include <cstdio> 

std::array<char, 100> init() 
{ 
    std::array<char, 100> arr = {'H', 'e', 'l', 'l', 'o', '\0'}; 
    return arr; 
} 

std::array<char, 100> arr = init(); 

int main() 
{ 
    puts(&*arr.begin()); 
} 

Answer 3

En C et C++, chaque valeur globale doit avoir sa taille et son type connus au moment de la compilation. La raison en est que ceux-ci finissent par être alloués dans une section du binaire lié. Si vous souhaitez que quelque chose soit à la fois global et dynamique, vous devez déclarer un global avec un type de pointeur ou un type contenant un pointeur, puis allouer rapidement les données dynamiques et mettre à jour le pointeur.