Best way to share global variables without using extern?

Question

so what I want is to have a global.h files that contain variables/functions for other classes/functions to use. For instance, say I have three header files: global.h, local1.h, and local2.h. Here, local1.h and local2.h are going to use variables from global.h. However, if I include global.h in both local1.h and local2.h, it would result in a multiple definition error as expected. I understand we can use the keyword "extern" but I heard its bad practice so I'm trying to avoid that.

I've tried to come along with this problem by using classes. Basically, I have a base class that contains variables that are all static. This way any class that would use those variables may just inherit from the base class. (in my case I'm fine with it as most of my programs are made out of classes). Below is the code,

Base.h

class base{
    static const int SCREEN_SIZE = 1000;
};

class1.h

#include "base.h"
class class1: public base{
    void printSize(){
        cout << SCREEN_SIZE << endl;
    }
};

class2.h

#include "base.h"
class class2: public base{
    int getSize(){
        return SCREEN_SIZE;
    }
};

But I'm not sure if this is the best way to do it, any suggestions?

Here's my actual code:

#ifndef GAME_CORE_H
#define GAME_CORE_H

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>
#include <stdio.h>

namespace Colors{
const SDL_Color RED = {255, 0, 0, 255};
const SDL_Color GREEN = {0, 255, 0, 255};
const SDL_Color BLUE = {0, 0, 255, 255};
const SDL_Color YELLOW = {255, 255, 0, 255};
const SDL_Color PURPLE = {128, 0, 128, 0};
const SDL_Color ORANGE = {255, 68, 0, 255};
const SDL_Color WHITE = {255, 255, 255, 255};
const SDL_Color BLACK = {0, 0, 0, 255};
};

namespace GAME_CORE{
SDL_Window* gWindow = NULL;
SDL_Renderer* gRenderer = NULL;
SDL_Surface* gWindowSurface = NULL;
TTF_Font* defaultFont = NULL;

const int SCREEN_INIT_WIDTH = 1280;
const int SCREEN_INIT_HEIGHT = 720;
const int TILESIZE = 32;

void CORE_Init();
};


#endif // GAME_CORE_H

so the error msg showed multiple definitions of gWindow, gRenderer, gWidowSurface, and defaultFont

Answer 1

I suggest .h files should be use for prototypes and not actually declaration of any types or functions except:

inline variables / functions static variables / functions const variables using int = Reg; typedef Reg int;

I prefer you implement it in two options

var.h
class var{
   public:
    var()=default;

  private:
     int _list {};

    operator +(int); //prototypes

};



var.cpp
//Then u can implement the declaration like
   #include"var.h"
    class var{
    //Implement it here

   };

Or you can do as the standard library does that declare full classes in files with no extension.

Here is a C program that can generate those files

int main (void){
   FILE* ptr = fopen ("vector","w+");
}

Answer 2

Use a header guard.

For example

Base.h

#ifndef base_h
#define base_h
class base{
    static const int SCREEN_SIZE = 1000;
};
#endif

Answer 3

At very first, if you include a header multiple times, you always get multiple definitions if you allow the code to get repeated by multiple inclusion. Using extern keyword to resolve the issue is not the way to go, you use that for other purposes. Apart from, it wouldn't work for classes!

The right way to do so is using include guards in the header file:

#ifndef SOME_GUARD_NAME
#define SOME_GUARD_NAME
// your code in between here
#endif

If you encounter#pragma once: That does the same job, but is non-standard. I don't know a recent compiler not supporting it, but if you want to stay fully portable, still add the include guards as fall-back!

extern keyword is used to tell the compiler that a variable exists, but is defined elsewhere. If you have globals accessed from different compilation units, then you need to define the global variable in exacly one of, while the others get aware of via a declaration (using extern keyword).

I do not see much of a problem having constants being defined as global variables (delcared extern):

// header file:

namespace Colors
{
extern const SDL_Color RED;
extern const SDL_Color GREEN;
extern const SDL_Color BLUE;
extern const SDL_Color YELLOW;
extern const SDL_Color PURPLE;
extern const SDL_Color ORANGE;
extern const SDL_Color WHITE;
extern const SDL_Color BLACK;
};

// source file:

const SDL_Color Colors::RED = {255, 0, 0, 255};
const SDL_Color Colors::GREEN = {0, 255, 0, 255};
const SDL_Color Colors::BLUE = {0, 0, 255, 255};
const SDL_Color Colors::YELLOW = {255, 255, 0, 255};
const SDL_Color Colors::PURPLE = {128, 0, 128, 0};
const SDL_Color Colors::ORANGE = {255, 68, 0, 255};
const SDL_Color Colors::WHITE = {255, 255, 255, 255};
const SDL_Color Colors::BLACK = {0, 0, 0, 255};

They are constants, so the trouble you can get into by global variables is avoided as these are not modifiable anyway (even concurrent read in multi-threaded environments is not a problem).

It is pretty easy, though, to lose overview over where and when mutable global variables are modified (it's the global variables being bad practice, not the extern keyword...). And you can add a big factor to that in multi-threaded environments. Bugs can easily arise from. That's why you usually avoid global variables.

Having an eye over your namespace GAME_CORE, then it looks pretty much as if it was a good idea to convert that into a class:

class GameCore
{
    // depends on how they are created, maybe std::unique_ptr is more appropriate?
    // you might avoid necessity of a destructor
    SDL_Window* m_window;
    SDL_Renderer* m_renderer;
    SDL_Surface* m_windowSurface;
    TTF_Font* m_defaultFont; // maybe rather a static constant?

public:
    // constants can easily be public:
    unsigned int const SCREEN_INIT_WIDTH = 1280;
    unsigned int const SCREEN_INIT_HEIGHT = 720;
    unsigned int const TILESIZE = 32;

    //void CORE_Init(); // replace this one with constructor:
    GameCore();

    //to properly clean up objects you created inside:
    ~GameCore(); // destructor 
};

You'd now convert all other functions accessing those GUI elements into member functions as well, some public, some private, just depending on the needs. Then you'd create a GUI like this:

int main()
{
    GameCore gc; // or possibly with parametrised: GameCore gc(7, 10, 12);

    // and use it from within main, e. g. simply:
    return gc.run();
}

If you still insist on global variables being accessed from different sources, then you do rely on extern keyword (but still use the include guards!)

// header file:

#ifndef SOME_GUARD_NAME
#define SOME_GUARD_NAME
namespace GAME_CORE
{
extern SDL_Window* gWindow; // no assignment!
// ...
}
#endif

// source file:

// you still need a definition in EXACTLY ONE compilation unit:
SDL_Window* GAME_CORE gWindow = nullptr;

Side note: You should prefer C++ keywords (nullptr) over old (obsolete) C macros (NULL) – unless explicitly writing code for old environments not supporting at least C++11.