MFC linker problem

[Radical Edward]

I am using visual C++ 6.0 here and I am having a problem with the linker, not sure why. here is what I am doing.

I am basically creationg the default MFC application, with SDI rather then MDI, and turning off printing. other than that, all things are default.

I create a simple header file called testclass.h which consists of the following:

class testclass
{
public:
testclass();
private:
int myInt;
};

testclass::testclass()
{
myInt = 1
}

////////////// that is all

then in the CmyDoc class I add the member variable

testclass theTest; // in the CmyDoc.cpp

and

#include "testclass.h" // in the CmyDoc.h file


and then compile. I get a LNK2005 error, saying I have already defined the .obj file

any idea why?

any help would be appreciated. ask me to describe things more if you need

[queball]

When you #include a function definition, you're effectively giving an implementation of that function each time. Every .c that #include's "testclass.h" - including those that #include "CmyDoc.h" - will redefine this function. I'll guess that "CmyDoc.h" is included from two different objects. Functions can only be implemented once or your linker will complain. However...

C++ does allow you to specify member functions in place, which will then be inlined wherever that function (or constructor) is used. Just keep in mind that this means more compilation, and might become worrisome when you use DLLs in the future.
class testclass
{
public:
testclass() { myInt = 1; }
private:
int myInt;
};

or:
testclass() : myInt (1) { }


The usual solution is to have a testclass.cpp, or just choose any one particular .cpp where you implement your function.

[JetLinus]

Originally Posted by queball

When you #include a function definition, you're effectively giving an implementation of that function each time. Every .c that #include's "testclass.h" - including those that #include "CmyDoc.h" - will redefine this function. I'll guess that "CmyDoc.h" is included from two different objects. Functions can only be implemented once or your linker will complain. However...

What about using (in the CmyDoc.h file):

#ifndef CMYDOC_H
#define CMYDOC_H

// stuff

#endif

If it should be #included multiple times, this stuff should do the trick, no?


I've only known C++ for 2 weeks now, but we were told to do this thing in every header file, and it made sense to me immediately!

[pablissimo]

I thought it was traditional to write class and method signatures in header files and their actual implementation in similarly named cpp files, though I don't do much C++

[queball]

Originally Posted by JetLinus

What about using (in the CmyDoc.h file):

#ifndef CMYDOC_H
#define CMYDOC_H

// stuff

#endif

If it should be #included multiple times, this stuff should do the trick, no?


I've only known C++ for 2 weeks now, but we were told to do this thing in every header file, and it made sense to me immediately!

That's to stop something being defined twice when compiling a source file, not to stop something being extraneously implemented by each of two objects. Compiler not linker.

[JetLinus]

Hm, don't really understand that (yet).
You're the experts. So well. Hope you'll find something to work it out then.
I'm out of ideas (as I have no clue about it).

[queball]

Originally Posted by JetLinus

Hm, don't really understand that (yet).

Say you have compiler-error.c:

#include "useful.h"
#include "useful.h"

(In reality you'd include the same thing twice indirectly rather than directly like this but the result is the same.)

And useful.h:

typedef struct { } useful_type;

Then my compiler errors, with the slightly unhelpful message "conflicting types for `useful_type'". This can be solved using #define's as you suggest. It's a compilation issue, it's solved with a compilation tool, the preprocessor.




Now say you have c1.c and c2.c, each identical:

typedef struct { } useful_type;
void useful_function() { }

Each will compile fine. It doesn't matter that you define the same type twice if it's in different files. In fact, you generally have to do so. Types are instructions for the compiler, so you need them included in each source file you use them in.

But when you try to link c1.o and c2.o the linker will error "multiple definition of `useful_function'". This is a linking issue, so isn't something solved using #define's in the manner you describe.

This is all second nature if you use the convention pab describes: useful.c for definitions, useful.h for declarations. I just wanted to point out that inline functions do indeed go in headers.

[JetLinus]

Ah I see... Cheers!

[Radical Edward]

queball was right in this case. I stripped out all the implementation into cpp files and it works a treat now. thanks