Vorlage, Verknüpfung und Trennung .h und .cc-Dateien

Ich persönlich lieber die Erklärung (.h) in eine separate Datei aus der definition (Ihren .cc-Datei). Auch ich möchte vermeiden, einschließlich der .cc-Datei in der .h-Datei. Methoden in einem .h-Datei sollte nur inline-Methoden.

Lassen Sie uns sagen, in Ihrem Beispiel, Sie hatten auch eine header-Datei (bar.h), die einfach deklariert eine Klasse, die eine Foo-Daten Mitglied.

Jedes mal, wenn Sie würden ändern Sie die definition der Klasse "Foo", Sie würde eine erneute Kompilierung wer schließt die bar.h, noch hart Sie konnte es nicht weniger Pflege über die definition von Foo. Allerdings bar.cpp ist wahrscheinlich, wo Sie auch tatsächlich umzusetzen, Sachen und, die Datei FUNKTIONIERT, müssen die Umsetzung Ihrer Vorlage. Dies trivial erscheinen in kleinen Projekten, sondern wird zu einer Quelle von Kopfschmerzen in großen Projekten, die ständig neu kompilieren, Dateien ohne Grund. Ich habe Menschen gesehen, die werfen SSDs und Incredibuild an Zeug, dass könnte behoben werden, indem einfach vorne erklärt und besser header-management.

Persönlich benutze ich .imp.h für die Umsetzung meiner Vorlagen. Einschließlich cc-files oder cpp-Dateien scheint yucky zu mir.

Z.B. ( sorry für die Kompilierung Fehler. 😉 )

//foo.h
#ifndef foo_h
#define foo_h
template< typename T >
struct Foo
{
   Foo( T value );
   void print();
   T _value;     
};
#endif

//foo.imp.h
#ifndef foo_imp_h
#define foo_imp_h
#include "foo.h"
#include <iostream>
template< typename T >
Foo< T >::Foo( T value ) : _value( value ) {}
void Foo< T >::print() { std::cout << _value << std::endl; }
#endif

//bar.h
#ifndef bar_h
#define bar_h
#include "foo.h"
struct Bar {
   Foo< int > _intFoo;
   Foo< double > _doubleFoo;
   void print();
};
#endif

//bar.cpp
#include "bar.h"
#include "foo.imp.h"
void Bar::print()
{
   _intFoo.print();
   _doubleFoo.print();
}

//foobar.cpp
#include "bar.h"
void foobar()
{
   Bar bar;
   bar.print();
}

Hatte die defintion von " foo " enthalten sein in oder von foo.h, bar.cpp und foobar.cpp müsste neu kompiliert wurde. Da nur bar.cpp befasst sich mit Foo ' s Umsetzung, die Aufteilung der defintion und Deklaration von Foo in zwei Dateien, und nicht foo.h include foo.imp.h am Ende hat mich gerettet zu kompilieren foobar.cpp.

Dies ist etwas, das passiert die ganze Zeit in Projekte und können sehr leicht vermeiden, indem Sie die folgenden die .h/.imp.h Regel, die ich oben erklärt. Der Grund, warum Sie nie sehen diese in Sachen wie STL oder boost ist, weil Sie nicht ändern dieser Dateien. Es spielt keine Rolle, wenn Sie in einer oder zwei Dateien. Aber in Ihren eigenen Projekten, Sie wird ständig ändern die Definitionen Vorlagen, und dies ist, wie Sie reduzieren die Neukompilierung Zeiten.

Wenn Sie bereits vorher wissen, welche Arten sind, die tatsächlich verwendet werden, Ihre Vorlage, als nicht einmal die Mühe, mit der .imp.h-Datei. Setzen Sie alles in einem .cpp und tun dies am Ende

//foo.cpp
//Implementation goes here.
//You might need to put something in front so that it gets exported from your DLL,
//depening on the platform
template class foo< int >;
template class foo< double >;

Inkl .cc-Dateien ist eine schlechte Nachricht und Niederlagen der Zweck der Trennung der Umsetzung von Erklärung.

Vorlagen in Kopfzeilen:

#ifndef FOO_H
#define FOO_H

template <class T>
class Foo {
   public:
      Foo (T);
      T get ();

   private:
      T data;
};

//implementation:


template <class T>
Foo :: Foo (T stuff) {
   data = stuff;
}

template <class T>
T Foo <T> :: get () {
   return data;
}

#endif

Wenn du wirklich lieber 2 Dateien, dann die zweite .h zu. Name it foo_impl.h oder sowas.

Da Sie auch foo.cc im foo.h gestalten Sie Ihr Leben einfacher, indem Sie alle den code in foo.h und loszuwerden foo.cc. Es gibt keinen Vorteil, davon gewonnen zu werden aufteilen des Codes in zwei Stücke.