"undefined reference to" in C++ (using g++)

I'm trying to compile a piece of code, but I keep getting the error:

undefined reference to X

where X is either a variable, or a function.

I get this despite the fact that those items appear to be in the header files, in some cases, right after a #define statement.

Why would I be getting this? It seems like 90% of the C++ files that are part of this project have this problem, I think for different things, but after the third or so I file I tested, I stopped bothering to read the whole line.

It looks to me like you have an undefined reference to X If you post the code, we would probably have a lot more to work with... the exact error would help also.

You should post some example error messages.

Undefined reference is typically a linker error, not a compiler error.

Typical causes of these are:
- missing functionality in the project, did you compile ALL the source files
- typo's in symbol names, myFunc != MyFunc
- missing libraries, where you're trying to make use of 3rd party code.

Including a header file only puts the declarations of external variables and functions into your code so the compiler can check that you're using them correctly. It makes no guarantee that those items will actually be found. Consider If those files refer to variables or functions that aren't defined in those two files, then the compiler will treat them as external references and leave the linker to figure out what they point to. Sometimes, those references are to things in the standard library (libstdc++) that the C++ linker will resolve automatically without having to be told. Most of the time, however, you need to pass an argument to g++ to tell the linker which library or libraries contain the items your code refers to. The most common example that trips up beginners is the math library: if you use functions in math.h, you will probably need to compile your code as: For any third-party library that is installed on your system, there are corresponding linker flags that you will need to use. If you use the math library and the SDL library, you would use: Another common cause of undefined symbols is when you have multiple source files of your own that you want to compile separately, but each file refers to variables or functions defined in the other files. In this case, you need to compile each file into an object file, not a complete executable, and then link the various object files together: I think that covers the most common causes for undefined symbols. If that doesn't help, post the complete compilation command and error message.

Okay, I was working on compiling some later code, and I think I found where they are defined (I HOPE its there). Anyway, some of the other code has some problems I have to deal with first (windows.h, for example) before I can try and compile all the code together in one call. Once I feel it is close to working I'll try compiling it all and sharing the results.

If you think there is a problem with the code in <windows.h> you are probably wrong!

Sorry, for responding late...
If I'm not mixing this up with another solution to a problem I had, what worked for me was to compile all the files together (I took out that reference to windows.h on suggestion in another thread).
So yeah, all those undefined references where defined in other files in the same project.

That is an ambiguous statement, and may either mean you did the right thing or a rather silly thing! You either have the terminology or the practice wrong.

All the project files should be compiled separately then linked together not compiled together.

What I am hoping you did not do was #include all the files into one large module, which may conceivably be what you meant.

Clifford

What I meant was, I compiled them all at the same time...so I guess I linked them together.
What I wrote was basically:

g++ foo1.cpp foo2.cpp foo3.cpp ... fooX.cpp

Maybe I have my terminology wrong, but I'm sending them all to the compile in the same command, so I'm compiling them together. The compiler, I assume, has an algorithm to handle such an action, wherein any shared functions or variables are taken care of, and is not really compiling them all together, nor simultaneously; but at the level of abstraction I am looking at it, as a user, it is a black box that is (as I see it) compiling them all together.

Sorry, just had to defend my word choice

But yeah, maybe linking them is a better choce of words...

You have your terminology wrong.

No it doesn't. While it makes sense to treat a compiler as a black box in some senses, the compilation mechanism shouldn't be ignored.

It matters. Terminology matters. Details matter. Shared functions? Functions that are defined in one source file and used in another? It's not automatically taken care of. You need to declare it. You need to make sure you have only one definition, and that every other file that uses it has the correct signature declared.

"Compiling together" makes no sense. Each file is compiled independently, and then linked together. Your usage of the compiler and the command line is irrelevant.

As was noted by someone earlier, g++ and cc are just drivers, they aren't compilers. They can be used to cause the files you listed compiled one at a time and then linked together. Both drivers run a compiler followed by running a linker or an archiver (in the case of building a library). Read your man pages on g++. It's been a while, but I think the command line would be man g++.

Fair enough. Note that g++ (you seem to have changed compiler driver again!) is not only a compiler driver, it can also invoke the linker (and does so by default; use -c for compilation only) which is what is happening here. You can invoke the linker (ld) directly to link previously compiled files, or you can use the compiler driver to link previously compiled object files (no compilation). The advantage of using the compiler driver is that it knows what standard libraries to link by default.

Clifford

You might also want to look into using a make file for your builds. This can allow you define dependencies between source, object and binary files so that whatever has modified will be updated accordingly. Particularly useful when you have a lot of files to compile and link.

man make