Circular Inclusion with Templates

The following code compiles perfectly:

// MyFile.h

#ifndef MYFILE_H_INCLUDED
#define MYFILE_H_INCLUDED

template <typename Datatype>
class MyClass
{
    public:
    void MyMethod();
}

#include "MyFile.c开发者_如何转开发pp"

#endif

// MyFile.cpp

#ifndef MYFILE_CPP_INCLUDED
#define MYFILE_CPP_INCLUDED

#include "MyFile.h"

template <typename Datatype>
void MyClass<Datatype>::MyMethod()
{
    // ...
}

#endif

The definitions of other methods and functions can be separated from the declarations in the same manner. Are there any downsides to using this approach? Can this behavior be relied upon?

• Rename the file "MyFile.cpp" to "MyFile.tpp".
• Remove the include guards from "MyFile.tpp"
• Change the include in "MyFile.h" so it is "MyFile.tpp"
• Remove the the include inside "MyFile.tpp"

Note: Because the file is a *.tpp file (not *.cpp) it should not be included by other build system operations. If you have added it manually remove it.

Make sure the only place that includes <X>.tpp is the last line in <X>.h

If you include the MyFile.tpp (I renamed it from .cpp), then you don't need to include the MyFile.h. #includeing a file is like exactly copying it's content into the file where it's included. Other from that, it's a common practice to organize the headers a bit. (Though you don't need the include-guards in the MyFile.tpp, because it should only ever be included from another header directly (like GMan says).)