Why does the C++ Compiler not find the function definitions?

Question

I wrote some code trying to understand the relationship between compiling and linking - and also to see where and if function declarations have to be repeated in source files.

The two files I wrote are:

Person.cpp:

#include <string>  
class Person {
  public:
   Person(std::string name) {
   (*this).name = name;
   };
   std::string getName() {
   return name;
   };
   std::string name;
};

and the file

PersonMain.cpp:

#include <iostream>
class Person {
  public:
    Person(std::string);
    std::string getName();
    std::string name;
 };
int main(){
          Person* charlie = new Person("Charlie");
          std::cout << "Hi, my name is " << charlie->getName();
          }

I repeat the Class Person and Class Person function declarations (not the definitions) in the PersonMain.cpp.

I now compile and link the two files using the gcc C++ Compiler:

g++ *.cpp -o runthis.exe

I then get the following error message:

PersonMain.cpp:(.text+0xfe): undefined reference to Person::Person(std::basic_string<char, std::char_traits<char>,std::allocator<char> >)' PersonMain.cpp:(.text+0x13c): undefined reference to Person::getName()' collect2.exe: error: ld returned 1 exit status

It seems the Person Class methods are not found when linking. Why is that? How can I heal this?

ADDENDUM:

I repeated the declaration of Person in PersonMain.cpp explicitly, and didn't but the redeclaration into a header file as would be done normally. So I've done the preprocessor step here already. This faq suggests that:

[The Preprocessor] works on one C++ source file at a time by replacing include directives with the content of the respective files (which is usually just declarations)[...]

and later on:

[The Linker] links all the object files by replacing the references to undefined symbols with the correct addresses. Each of these symbols can be defined in other object files or in libraries.

I add this remark becaue @engf-010 said that a Compilation Unit that has code that isn't actually used in that compilation unit is not compiled, even if it is needed in other compilation units. enf-010 suggests that I put the definition and declaration into the header file, but the faq article says that only the declarations should go there, the definitions can be elsewhere.

Answer 1

Usually one splits declarations and definitions into .h and .cpp files respectively.

Your code would look something like this:

person.h - declarations:

#include <string>

class Person {
public:
        Person(std::string n);
        std::string getName() const;

        std::string name;
};

person.cpp - implementation:

#include <string>
#include "person.h"

Person::Person(const char* n) : name(n) { }
std::string Person::getName () const { return name; }

and personmain.cpp - where you use your class Person:

#include <iostream>
#include "person.h"

int main()
{
        Person* charlie = new Person("Charlie");
        std::cout << "Hi, my name is " << charlie->getName ();
}

Like @engf mentioned, essentially, what you got in your code is double definition of Person and no implementation. You can't easily define Person in main file and implement Person::Person() somewhere else (and you should not), in another translation unit (i.e., in person.cpp), without letting the compiler know what you implement. You can't forward-declare Person and use it in personmain.cpp like this:

class Person;
...
Person* charlie = new Person("whatever");

because compiler should know complete type to emit code constructing the Person-object. You can't have two definitions of Person. You can't implement members of Person without definitions, accessible to all users of your code. So, what you left with is the scheme like this above.

To elaborate a bit more on compilation and linking, very roughly, when compiler sees a reference to symbol not defined locally in the same translation unit, it puts appropriate record into object file. When this object file is passed to the linker (possibly, along with a bunch of other object files and libraries), linker should resolve such records to symbols (functions, variables etc.) found somewhere in input object files or libraries. If it succeeds in that, it combines all the referenced code into single image. In your case the linker failed to resolve referenced symbol Person::Person for constructor. Probably this is not bad Q&A to start.

Answer 2

what you've got is a definition in one source file and a declaration in the other source file. When the source file containing the definition is compiled ,the compiler comes to the conclusion that there isn't any 'real' code to generate ,because you didn't use the class. So you end up with an empty object file.

You can define a class in a source file but if you don't use that class in that file it is tossed away as not being used. If you use that class in other source files (through it's declaration) the compiler generates code for member accesses ,but those are not found during linking.