C++ – Compiling with g++ – including header files

c++g++header

I just have a quick question as I'm trying to understand how to compile (in ubuntu 12.04) a main in c++ that includes a simple header file.

The command:

g++ -o main main.cpp add.cpp -Wall

Works fine. However, that confuses me about the point of the header file. At the moment, I have the simple program:

#include <iostream>
#include "add.h"
using namespace std;

int main () {


  int a, b;
  cout << "Enter two numbers to add together" << endl;
  cin >> a >> b;
  cout << "Sum of " << a << " and " << b << " is " << add(a,b) << endl;

  return 0;

}

Where my "add.cpp" is simply adding the two numbers together.

Is the header file simply a replacement for the function prototype? Do I need to compile the header file separately or is it sufficient to include all of the .cpp files in the command line? I understand that if I need more files a makefile would be necessary.

Best Solution

The #include preprocessor code just replaces the #include line with the content of the corresponding file, which is add.h in your code. You can see the code after preprocessing with g++ argument -E.

You can put theoretically anything in the header file, and the content of that file will be copied with a #include statement, without the need to compiling the header file separately.

You can put all the cpp file in one command, or you can compile them separately and link them in the end:

g++ -c source1.cpp -o source1.o
g++ -c source2.cpp -o source2.o
g++ -c source3.cpp -o source3.o
g++ source1.o source2.o source3.o -o source

EDIT

you can also write function prototypes direct in cpp file like (with NO header file):

/* add.cpp */
int add(int x, int y) {
    return x + y;
}

/* main.cpp */
#include <iostream>
using namespace std;

int add(int x, int y);    // write function protype DIRECTLY!
// prototype tells a compiler that we have a function called add that takes two int as
// parameters, but implemented somewhere else.

int main() {
    int a, b;
    cout << "Enter two numbers to add together" << endl;
    cin >> a >> b;
    cout << "Sum of " << a << " and " << b << " is " << add(a,b) << endl;
    return 0;
}

It also works. But using header files is preferred since prototypes might be used in multiple cpp files, without the need of changing every cpp file when the prototype is changed.

Related Solutions

C++ – Why can templates only be implemented in the header file

Caveat: It is not necessary to put the implementation in the header file, see the alternative solution at the end of this answer.

Anyway, the reason your code is failing is that, when instantiating a template, the compiler creates a new class with the given template argument. For example:

template<typename T>
struct Foo
{
    T bar;
    void doSomething(T param) {/* do stuff using T */}
};

// somewhere in a .cpp
Foo<int> f;

When reading this line, the compiler will create a new class (let's call it FooInt), which is equivalent to the following:

struct FooInt
{
    int bar;
    void doSomething(int param) {/* do stuff using int */}
}

Consequently, the compiler needs to have access to the implementation of the methods, to instantiate them with the template argument (in this case int). If these implementations were not in the header, they wouldn't be accessible, and therefore the compiler wouldn't be able to instantiate the template.

A common solution to this is to write the template declaration in a header file, then implement the class in an implementation file (for example .tpp), and include this implementation file at the end of the header.

Foo.h

template <typename T>
struct Foo
{
    void doSomething(T param);
};

#include "Foo.tpp"

Foo.tpp

template <typename T>
void Foo<T>::doSomething(T param)
{
    //implementation
}

This way, implementation is still separated from declaration, but is accessible to the compiler.

Alternative solution

Another solution is to keep the implementation separated, and explicitly instantiate all the template instances you'll need:

Foo.h

// no implementation
template <typename T> struct Foo { ... };

Foo.cpp

// implementation of Foo's methods

// explicit instantiations
template class Foo<int>;
template class Foo<float>;
// You will only be able to use Foo with int or float

If my explanation isn't clear enough, you can have a look at the C++ Super-FAQ on this subject.

C++ – Declaring class objects in a header file

Declare Obj1 and Obj2 in your .cpp instead of at .h

add.h

class SA {
 ...
public
    int x;
};

main.cpp

#include "additional.h" 

SA Obj1, Obj2;

int main() {

 Obj1.x = 5;

 ...
}

If you want to declare Obj1 and Obj2 in your .h file, add extern in the .h file like so:

extern SA Obj1, Obj2;

but you should declare the objects in a .cpp file in your project: