将头文件（.h）放在另一个文件（.h 或 .cpp）的开头和结尾的区别

Question

Recently , I was compiling libfacebookcpp on mac os. I found a strange usage which I can't understand. There are two files, AuthorizedObject.hpp and List.hpp. At the end of file AuthorizedObject.hpp,there is one line :#include "List.hpp".Now I compile successfully. But when I move that line to the beginning, error occurs. The skeleton of the codes are:

//AuthorizedObject.hpp
class AuthorizedObject
{
public:
... 
template<class TType>
void _GetConnection(const ::std::string& uri, List<TType> *list) const
{
    LIBFACEBOOKCPP_CHKARG(list);

    Json::Value value;
    request_->GetResponse(uri, &value);

    list->Deserialize(*this, value);
}
...
}
#include "List.hpp" //end

----------------------------------------------------------
//List.hpp 
#include "AuthorizedObject.hpp"
class LIBFACEBOOKCPP_API List : public AuthorizedObject
{
private: // private classes
...
}

I guess if put that line(#include "List.h") at the beginning of AuthorizedObject.hpp, the two files include each other by circle. So the compiler don't know how to compile.But put that line at the end will solve this problem? Why? Thank you in advance.

Answer 1

The difference is in what order classes/functions/... are defined, for example:

#include "one.h"
void foo(bar &);

// Will result into:
class bar {};
void foo(bar&);

Which is valid code. On the other hand:

void foo(bar &);
#include "one.h"

// Will result into statements in different order:
void foo(bar&);
class bar {};

Which means using class bar before it was declared, thus error. You also may need to make sure that no declaration will be processed twice ( UmNyobe already covered that partially ):

#if !defined( MY_HEADER_INCLUDED_)
# define MY_HEADER_INCLUDED_
// Complete content goes here
#endif /* !defined( MY_HEADER_INCLUDED_) */

This way when you include file for the first time, MY_HEADER_INCLUDED_ won't be defined (contents will be "placed" inside the code). The second time (you will include it in the circle) MY_HEADER_INCLUDED_ will be defined and therefore complete body will be skipped.

Answer 2

You're right, that's the problem. You're wrong that the compiler doesn't know how to compile - it does, you're just using it wrong :).

The include guards at the beginning of AuthorizedObject.hpp (I assume it has include guards or a #pragma once directive) will define AUTHORIZED_OBJECT_H (or similar). After that, you include List.h , which in turn includes the header AuthorizedObject.hpp . Because the include guard macro was already defined, the definition of AuthorizedObject is skipped, so List doesn't know about the type, but is uses it, so you get the error.

If you move the include at the end, the definition of AuthorizedObject was already processed by the compiler, so using it inside List.h is valid.