Linker error for multiply defined symbols

Question

I have the following file structure:

X.h

#pragma once

#include "Y.h"

int ONE = 1;

int combine();

X.c

#include "X.h"

int combine()
{
    return ONE + TWO;
}

Y.h

#pragma once

int TWO = 2;

Y.c

#include "Y.h"

Main.c

#include "X.h"

int main()
{
    int fusion = combine();

    return 0;
}

I get the following errors:

LNK1169 one or more multiply defined symbols found

LNK2005 _ONE already defined in Main.obj

LNK2005 _TWO already defined in Main.obj

KLNK2005 _TWO already defined in Main.obj

This makes zero sense. If we start at Main.c the compiler must include X.h. The compiler then looks for the C file associated with X.h. Inside X.c it needs to include X.h but #pragma once SHOULD guard against that. Then it needs to include Y.h. It looks for the C file and finds Y.c which says to include Y.h, but Y.h has already been included. Then, it returns to Main.c and should successfully compile... but nope.

I can add /FORCE to my project settings which makes my code run perfectly but still outputs the:

ONE has already been defined, second definition ignored.

Answer 1

but #pragma once SHOULD guard against that

#pragma once is used to avoid reduplicate including within single translation unit (.c file in this case), but it can't prevent multiple definition crossing multiple translation unit.

You're defining global variable ONE and TWO in .h file, and they're included in multiple translation unit and cause multiple definition error.

For example, finally, ONE will be defined in X.c and Main.c, TWO will be defined in Y.c, X.c and Main.c.

You should declare ONE and TWO in .h file (by using extern), and define them in .c file.

X.h

#pragma once

#include "Y.h"

extern int ONE;
int combine();

X.c

#include "X.h"

int ONE = 1;

int combine()
{
    return ONE + TWO;
}

Y.h

#pragma once

extern int TWO;

Y.c

#include "Y.h"

int TWO = 2;

Answer 2

#pragma once only guards against the same header being included twice in the same compilation unit. It does not prevent problems when you define the same variable in multiple compilation units.

To see what's wrong, let's walk through what each compilation unit looks like as it's being compiled.

After preprocessing, X.c ends up looking like this:

int TWO = 2;

int ONE = 1;

int combine();

int combine()
{
    return ONE + TWO;
}

As you can see, it contains definitions for the symbols TWO, ONE, and combine.

Y.c ends up looking like this:

int TWO = 2;

It also defines the symbol TWO.

main.c looks like this:

int TWO = 2;

int ONE = 1;

int combine();

int main()
{
    int fusion = combine();

    return 0;
}

So it also has definitions for TWO and ONE, along with main.

So after compilation, we end up with 3 object files, all three of which have definitions for TWO, and two of which have definitions for ONE. When we get to linking, the linker sees references to ONE and TWO in the definition of combine and goes looking for those symbols' definitions. Since they're defined in multiple places, it throws an error and gives up.

You can fix this problem by declaring ONE and TWO in X.h and Y.h and defining ONE and TWO in X.c and Y.c.

Answer 3

#pragma once prevents a header file from getting included more than once when compiling a single source module.

That's all it does.

Your header file is getting included from two different source modules.

That header file declares and defines an object in global scope.

Both of your two source modules, therefore, end up defining the same object in global scope.

And that's where the duplicate symbol definition comes from.

#pragma once is not a substitute for knowing and understanding C++ scoping rules.