Déclaration des variables globales du langage C

Objectif

Comment utiliser les variables globales et leur confirmation

*** J'ai reçu beaucoup de conseils de @fujitanozomu, j'ai donc révisé ce mémo de manière significative. Je souhaite conserver autant que possible l'historique des révisions, mais je n'ai pas pu afficher la différence du fichier programme, j'ai donc modifié uniquement l'article. *** ***

Fichier

main.c: ~~ global ~~ ~~ déclaration de la variable num ~~ A et B *** dans la définition et l'ordre (A et B sont des fonctions externes. Vérifiez si la variable est définitivement globale en externe) ** * Processus *** (Addition) main.h: Déclarez la variable num avec extern. Dans d'autres fichiers c, la variable num devient globale en incluant cet en-tête. *** *** A.h: ~~ Déclare utiliser la variable globale num ~~ Déclare la fonction A à utiliser en externe A.c: Inclure *** main.h et changer *** num en sortie (la variable globale num est modifiée) B.h: ~~ Déclare utiliser la variable globale num ~~ Déclare la fonction B à utiliser en externe B.c: Inclure *** main.h et la sortie sans changer *** num (la variable globale de sortie num a changé dans A)

Dans le fichier ci-dessus, num déclaré dans main peut être utilisé à partir de A et B (car il devient une variable globale), et même si num est modifié dans A, il est prouvé que le changement peut également être confirmé à partir de B.

Le contenu du fichier

main.c

#include"main.h"
#include"A.h"  //Pour utiliser la fonction de A
#include"B.h"  //Pour utiliser la fonction de B

int num;   //Déclarer des variables

int main(int argc, char *argv[]){
    A();   //Changer num dans un autre fichier
    B();   //Vérifier le nombre modifié dans d'autres fichiers
    return 0;
}

main.h

extern int num;  //Autres fichiers (voici les principaux.Cela signifie que num est défini en c)

A.h

extern void A();  //A.La fonction A définie en c est déclarée en extern pour un usage externe

A.c

#include<stdio.h>
#include"A.h"
#include"main.h"  //Où num devient mondial

 void A(){
     num = 10;   //Changer les variables globales
     printf("inside A, num = %d\n", num);   //Changer la variable globale et la sortie
 }

B.h

extern void B();  //B.La fonction B définie en c est déclarée en extern pour un usage externe

B.c

#include<stdio.h>
#include"B.h"
#include"main.h"  //Où num devient mondial

void B(){
    printf("inside B, num = %d\n", num);   //Sortie sans modifier les variables globales
}

#Créer une bibliothèque partagée pour A
[pirlo@centos8 02]$ gcc -shared -o libA.so -c A.c
#Créer une bibliothèque partagée pour B
[pirlo@centos8 02]$ gcc -shared -o libB.so -c B.c
#Compilez le processus principal et créez un fichier exécutable
[pirlo@centos8 02]$ gcc -o main main.c -L. -lA -lB
#Liste des fichiers
[pirlo@centos8 02]$ ls
A.c  A.h  B.c  B.h  libA.so  libB.so  main  main.c  main.h

Résultat d'exécution

[pirlo@centos8 02]$ ./main 
inside A, num = 10   #Changer la variable globale avec A
inside B, num = 10   #Vérifiez les variables globales modifiées de B à A

*** Addenda ***

https://www.geeksforgeeks.org/understanding-extern-keyword-in-c/

*** Selon cet article, les fonctions sont différentes des variables, et une fois compilées, le compilateur les traite comme si elles avaient des externs, il semble donc que vous n'ayez pas à spécifier des externs. Quand je l'ai testé, j'ai pu le compiler et l'exécuter même si j'ai supprimé #include "A.h" et #include "B.h" de main.h. *** ***