How to prevent multiple definitions in C?
You actually compile the source code of test.c
twice:
- The first time when compiling
test.c
itself, - The second time when compiling
main.c
which includes all thetest.c
source.
What you need in your main.c
in order to use the test()
function is a simple declaration, not its definition. This is achieved by including a test.h
header file which contains something like:
void test(void);
This informs the compiler that such a function with input parameters and return type exists. What this function does ( everything inside {
and }
) is left in your test.c
file.
In main.c, replace #include "test.c"
by #include "test.h"
.
A last point: with your programs being more complex, you will be faced to situations when header files may be included several times. To prevent this, header sources are sometimes enclosed by specific macro definitions, like:
#ifndef TEST_H_INCLUDED
#define TEST_H_INCLUDED
void test(void);
#endif
Multiple definition of ... linker error
Don't define variables in headers. Put declarations in header and definitions in one of the .c files.
In config.h
extern const char *names[];
In some .c file:
const char *names[] = {
"brian", "stefan", "steve" };
If you put a definition of a global variable in a header file, then this definition will go to every .c file that includes this header, and you will get multiple definition error because a varible may be declared multiple times but can be defined only once.
Also, one more thing you can do if you have to define your variables inside of a header file you can use the static
keyword.
static const char *names[] = {
"brian", "stefan", "steve" };
This way variable names
will be defined only once in your entire program and can be accessed multiple number of times.
Compiling error with errors like multiple definition
Inside your header file, you should declare your variable like:
extern const int khStrInt;
Then in a .c file, you should define it like:
const int khStrInt = 33;
This means the variable definition is only generated once by the compiler when compiling the .c file and so the linker doesn't see multiple definitions. Also, having the declaration in the header file allows other files which include the header to be able to use the variable.
Multiple definition, first defined here errors
The problem here is that you are including commands.c
in commands.h
before the function prototype. Therefore, the C pre-processor inserts the content of commands.c
into commands.h
before the function prototype. commands.c
contains the function definition. As a result, the function definition ends up before than the function declaration causing the error.
The content of commands.h
after the pre-processor phase looks like this:
#ifndef COMMANDS_H_
#define COMMANDS_H_
// function definition
void f123(){
}
// function declaration
void f123();
#endif /* COMMANDS_H_ */
This is an error because you can't declare a function after its definition in C. If you swapped #include "commands.c"
and the function declaration the error shouldn't happen because, now, the function prototype comes before the function declaration.
However, including a .c
file is a bad practice and should be avoided. A better solution for this problem would be to include commands.h
in commands.c
and link the compiled version of command to the main file. For example:
commands.h
#ifndef COMMANDS_H_
#define COMMANDS_H_
void f123(); // function declaration
#endif
commands.c
#include "commands.h"
void f123(){} // function definition
Multiple definition error on variable that is declared and defined in header file and used only in its cpp file
If you declare your variable in the header file:
#ifndef GLOBAL_H
#define GLOBAL_H
int foo = 0;
#endif
In every include of your header file or translation unit, a new instance of your integer is created. As you mentioned, to avoid this, you need to declare the item as "extern" in the header file and initialize it in the implementation file:
// .h
extern int foo;
// .cpp
int foo = 0
A more C++ way to do that can be something like this:
#ifndef GLOBAL_H
#define GLOBAL_H
struct Global {
static int foo;
};
#endif
And in your cpp file:
#include "variables.h"
int Global::foo = 0;
C++17 fixes this problem with inline variables, so you can do:
#ifndef GLOBAL_H
#define GLOBAL_H
inline int foo = 0;
#endif
See How do inline variables work? for more information.
how to fix multiple definition error in c++?
Others already have explained the cause of the error: you are defining the same global variables in multiple translation units.
A possible fix is to define them in just one point and declare them as extern
in the header file.
However, in my opinion the real question is: do you really need those global variables? If they are meant to be part of the state of a queue object, we should make them instance variables.
class Queue{
public:
Node *nNode(int value);
void add(int value);
void remove();
void display();
void firstItem();
Queue()
{
start = NULL;
end = NULL;
}
Node *start, *end; // <----
};
In this way we can use multiple queue objects at runtime, and each of them will manage its own data. By comparison, instantiating many objects of the original class is useless, since they will all operate on the same queue.
TL;DR: encapsulate your state, avoid globals.
Related Topics
Get Current Time in Milliseconds, or Hh:Mm:Ss:Mmm Format
Convert from an Infix Expression to Postfix (C++) Using Stacks
Why Should I Not #Include ≪Bits/Stdc++.H≫
How to Tokenize a String in C++
Is Segmentation Fault Actual Undefined Behavior When We Refer to a Non-Static Data-Member
If You Shouldn't Throw Exceptions in a Destructor, How to Handle Errors in It
Placement of the Asterisk in Pointer Declarations
Fastest Way to Check If a File Exists Using Standard C++/C++11,14,17/C
How Come a Non-Const Reference Cannot Bind to a Temporary Object
Rule-Of-Three Becomes Rule-Of-Five With C++11
Difference Between 'Struct' and 'Typedef Struct' in C++
How to Read an Entire File into a Std::String in C++