Why do I have to explicitly include the header file in a code?

Here is the code

Code:

//vector.h
int add(int x, int y);

//vector.cc
#include <iostream>

int add(int x, int y){
  return (x+y);
}

int main(){
    std::cout<<add(1,1)<<std::endl;
    return 0;
}

Obviously I do NOT need to include vector.h to compile. However, when I use namespace:

Code:

//vector.h
namespace TEST{
  int add(int x, int y);
}


//vector.cc
#include <iostream>
#include "vector.h"

int TEST::add(int x, int y){
  return (x+y);
}

int main(){
    std::cout<<TEST::add(1,1)<<std::endl;
    return 0;
}

I have to include "vector.h" otherwise compiler complains:

Code:

> g++ -o vec vector.cc
vector.cc:5: error: syntax error before `::' token
vector.cc: In function `int main()':
vector.cc:10: error: `TEST' undeclared (first use this function)
vector.cc:10: error: (Each undeclared identifier is reported only once for each 
   function it appears in.)
vector.cc:10: error: parse error before `::' token

Anybody knows why is that?

All functions and objects need to be explicitly listed in a namespace somewhere in order to be compiled correctly, that's the difference.

The compiler can't magically see functions in C++. So if you try to call a function that is not defined in the current file (or it's defined BELOW the function you're calling it from), then you must inform the compiler that the function will be there later.
This is done using prototypes, which are typically placed in header files.

Your first example works because you define the function before the call.
The second fails because the compiler doesn't know of any TEST namespace (you haven't created one, and especially not placed a function inside it).

However, you can do:

Code:

namespace TEST
{
    int add(int x, int y)
    {
        return (x+y);
    }
}

And it will compile without the header (because you are telling the compiler to create the namespace and inside it, the function is defined).

Originally Posted by Elysia

The compiler can't magically see functions in C++. So if you try to call a function that is not defined in the current file (or it's defined BELOW the function you're calling it from), then you must inform the compiler that the function will be there later.
This is done using prototypes, which are typically placed in header files.

What you say here is correct, except that you have used the word "defined" when the correct word to use was "declared".

A function prototype is a declaration, but it is not a definition.

I was referring to the actual definition and not the declaration, though.
If a function is defined above the function that calls it, no prototype is necessary.
If it's below or is another file, a prototype or declaration is necessary.

Originally Posted by Elysia

I was referring to the actual definition and not the declaration, though.
If a function is defined above the function that calls it, no prototype is necessary.
If it's below or is another file, a prototype or declaration is necessary.

This is because a definition is a declaration, although the converse is not true. A declaration for a function must exist at the time it is referenced. This declaration could come from a prototype, or from a previous definition of the function. If a function is defined, and a previous declaration exists (i.e. a prototype from a header file), the declarations must match each other.