🚀 go-pugleaf

Thomas Lionel SMETS wrote:

...

> I wish to have two classes in two separated files, as such :
> 
> ============== B E G I N    O F   F I L E  1   ====================
> #include ...   // Only standart header files <iostream>, etc ...
> class ClassName1 {
>     // Implementation
> 
> }
> ============== E N D   O F    F I L E  1 =======================
> 
> ============== B E G I N    O F   F I L E  2   ====================
> #include ...   // Only standart header files <iostream>, etc ...
> class ClassName2 : class ClassName1 {
>     // Implementation
> 
> }

...

> Now the question is :
>     How do I compile this properly ?
> 

...

> Thanks in advance,
> 
> Thomas,
> 
> --
> mail : thomas.smets@gonthier-be.com (professionnel)
>        tsmets@altern.org (privé)

Classes generally have two parts: the class definition, and the
definitions of any member functions.  For example,

// define class First
class First
{
public:
  float fish(); //declare a member function called fish
// ...
private:
  int x; // declare an int data member
}; // end of class definition

// define member functions of First
float First::fish()
{
  return x*2.4;
}

Any source code which uses the class First needs access to the
definition of the class at compile time*, which includes the
declarations of the member functions (their names and argument and
return types).  It does not need access to the definitions of the member
functions (in object file .o form) until link time.  Thus, if I want to
define a class Second which inherits from First, but put that definition
in a separate file, I would organize the code as follows:

// file: First.h
class First
{
//define First
};

// file: First.C
#include "First.h"
// This insures that First.C uses the same definition of class First as
// everyone else.

// define member functions of First


// file: Second.C
#include "First.h"

class Second : public First
{
  float red_fish();
// define Second
};

// define members of Second
float Second::red_fish()
{
  return fish()*0.5; // half of fish are red
}


main()
{
// use Second
}

Then, I would compile First with

  g++ -c First.C

and compile and link Second with

  g++ -c Second.C

(#include gives g++ access to definition of First when compiling
Second.C)

  g++ -o together First.o Second.o

(linking with First.o gives the linker access to First's member
functions
so that it can fill in the function call to First::fish from
Second::red_fish)

or simply

  g++ -o together Second.C First.o


Of course, if I wanted to use class Second in another file,I should
separate its definition into Second.h.  Further complications could
arise if I wanted to use both classes in a third file.  Suppose I wrote

// file: Third.C
#include "First.h"

#include "Second.h"
// error: attempts to redefine class First, since Second.h also
// includes First.h

First f;
Second g;

In this case, I could avoid multiple definitions by simply omitting the
first (or do I mean First :-) #include in Third.C.  However, I would
have to remember that Second.h included First.h.  I could head off this
potential problem by changing the file First.h as follows:

// file: First.h, version 2
#ifndef MY_FIRST_CLASS
#define MY_FIRST_CLASS

// define First
class First
{
// ...
};

#endif

The extra # declarations to the preprocessor insure that only one
definition of First is included in any given source file which is
compiled.

David Fox



*except if the code only declares a pointer to an object of class First.