CODEWITHSUNDEEP
cvariableslinkerglobal-variablesscope
Claudiu
Claudiu

Reputation: 229361

shared global variables in C

How can I create global variables that are shared in C? If I put it in a header file, then the linker complains that the variables are already defined. Is the only way to declare the variable in one of my C files and to manually put in externs at the top of all the other C files that want to use it? That sounds not ideal.

Upvotes: 90

Views: 226813

Answers (7)

jim mcnamara
jim mcnamara

Reputation: 16379

In the header file share.h:

#ifndef SHAREFILE_INCLUDED
#define SHAREFILE_INCLUDED

#ifdef  MAIN_FILE
int global;
#else
extern int global;
#endif

#endif

Use the following in the source file in which you want the global variable to live:

#define MAIN_FILE
#include "share.h"

In the other files that need the extern version, use:

#include "share.h"

Upvotes: 22

Fabiano Traple
Fabiano Traple

Reputation: 111

There is a more elegant way to create global variables.

Just declare the variables as static inside a ".c" source file and create set/get functions.

The example below I use to override malloc, realloc and free functions during memory allocation tests.

Example:

memory-allocator.h

#ifndef MEMORY_ALLOCATOR_H_
#define MEMORY_ALLOCATOR_H_

#include <stddef.h>

void std_set_memory_allocators(void *(*malloc)(size_t size),
                               void *(realloc)(void *ptr, size_t size),
                               void (*free)(void *ptr));

void std_set_reset_allocators();

void *std_malloc(size_t size);

void *std_realloc(void *ptr, size_t size);

void std_free(void *ptr);

#endif  // MEMORY_ALLOCATOR_H_

memory-allocator.c

#include "memory-allocator.h"

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    void *(*malloc)(size_t size);
    void *(*realloc)(void *ptr, size_t size);
    void (*free)(void *ptr);
} StdMemoryAllocator;

StdMemoryAllocator memory_allocators = {&malloc, &realloc, &free};

void std_set_memory_allocators(void *(*malloc)(size_t size),
                               void *(realloc)(void *ptr, size_t size),
                               void (*free)(void *ptr)) {
    memory_allocators.malloc = malloc;
    memory_allocators.realloc = realloc;
    memory_allocators.free = free;
}

void std_set_reset_allocators() {
    memory_allocators.malloc = malloc;
    memory_allocators.realloc = realloc;
    memory_allocators.free = free;
}

void *std_malloc(size_t size) {
    return memory_allocators.malloc(size);
}

void *std_realloc(void *ptr, size_t size) {
    return memory_allocators.realloc(ptr, size);
}

void std_free(void *ptr) {
    memory_allocators.free(ptr);
}

The struct static struct StdMemoryAllocator_s memory_allocators is started automatically when the application starts, and it point to the default C memory allocators.

Upvotes: 0

ivan
ivan

Reputation: 21

There is a cleaner way with just one header file so it is simpler to maintain. In the header with the global variables prefix each declaration with a keyword (I use common) then in just one source file include it like this

#define common
#include "globals.h"
#undef common

and any other source files like this

#define common extern
#include "globals.h"
#undef common

Just make sure you don't initialise any of the variables in the globals.h file or the linker will still complain as an initialised variable is not treated as external even with the extern keyword. The global.h file looks similar to this

#pragma once
common int globala;
common int globalb;
etc.

seems to work for any type of declaration. Don't use the common keyword on #define of course.

Upvotes: 2

Dig
Dig

Reputation: 3950

In the header file write it with extern. And at the global scope of one of the c files declare it without extern.

Upvotes: 71

tritinia
tritinia

Reputation: 61

If you're sharing code between C and C++, remember to add the following to the shared.hfile:

#ifdef __cplusplus
extern "C" {
#endif

extern int my_global;
/* other extern declarations ... */

#ifdef __cplusplus
}
#endif

Upvotes: 6

Hern&#225;n
Hern&#225;n

Reputation: 4587

In one header file (shared.h):

extern int this_is_global;

In every file that you want to use this global symbol, include header containing the extern declaration:

#include "shared.h"

To avoid multiple linker definitions, just one declaration of your global symbol must be present across your compilation units (e.g: shared.cpp) :

/* shared.cpp */
#include "shared.h"
int this_is_global;

Upvotes: 100

nos
nos

Reputation: 229108

You put the declaration in a header file, e.g.

 extern int my_global;

In one of your .c files you define it at global scope.

int my_global;

Every .c file that wants access to my_global includes the header file with the extern in.

Upvotes: 16

Related Questions