Пикша для Установленных на интриге модулей?

Вы не можете передать, объявляют "части" классов как этот. Даже если бы Вы могли, Вы должными быть все еще инстанцировать кода где-нибудь, таким образом, Вы могли связаться против него. Существуют способы обработать его, Вы могли сделать себя небольшой библиотекой с инстанцированиями общих контейнеров (например, вектор) и связать их в. Затем необходимо было бы только когда-либо компилировать, например, vector< int> однажды. Для реализации этого, необходимо будет использовать что-то как [1 110], по крайней мере, предполагая, что Вы придерживаетесь g ++ и явно инстанцируете шаблона в своем lib с [1 111]

Так, реальный рабочий пример. Здесь у меня есть 2 файла, a.cpp и b.cpp

a.cpp:

#include <vector> // still need to know the interface
#include <cstdlib>

int main(int argc, char **argv) {
  std::vector<int>* vec = new std::vector<int>();
  vec->push_back(3);
  delete vec;
  return EXIT_SUCCESS;
}

Поэтому теперь я могу скомпилировать a.cpp с [1 112]:

g++ -fno-implicit-templates -c a.cpp

Это даст мне a.o. Если я затем, я пытаюсь связать a.o, который я получаю:

g++ a.o
/usr/bin/ld: Undefined symbols:
std::vector<int, std::allocator<int> >::_M_insert_aux(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int const&)
void std::_Destroy<int*, std::allocator<int> >(int*, int*, std::allocator<int>)
collect2: ld returned 1 exit status

Отрицательный результат. Таким образом, мы обращаемся к b.cpp:

#include <vector>
template class std::vector<int>;
template void std::_Destroy(int*,int*, std::allocator<int>);
template void std::__uninitialized_fill_n_a(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, unsigned long, int const&, std::allocator<int>);
template void std::__uninitialized_fill_n_a(int*, unsigned long, int const&, std::allocator<int>);
template void std::fill(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int const&);
template __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > std::fill_n(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, unsigned long, int const&);
template int* std::fill_n(int*, unsigned long, int const&);
template void std::_Destroy(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, std::allocator<int>);

Теперь Вы говорите себе, откуда сделал все эти дополнительные шаблонные вещи, прибывшие? Я вижу template class std::vector<int>, и это прекрасно, но что относительно остальной части его? Хорошо короткий ответ - то, что, эти вещи реализации при необходимости немного грязны, и когда Вы вручную инстанцируете их, следовательно часть этого беспорядка просачивается. Вы, вероятно, задаетесь вопросом, как я даже выяснил то, чего я должен был инстанцировать. Хорошо я использовал ошибки компоновщика ;).

Поэтому теперь мы компилируем b.cpp

g++ -fno-implicit-templates -c b.cpp

, И мы получаем b.o. Соединение a.o и b.o мы можем добраться

g++ a.o b.o

Ура, никакие ошибки компоновщика.

Так, для вхождения в некоторые детали об обновленном вопросе если это - домашний варивший класс, это должно не обязательно быть это грязное. Например, можно разделить интерфейс от реализации, например, сказать, что у нас есть c.h, c.cpp, в дополнение к a.cpp и b.cpp

c.h

template<typename T>
class MyExample {
  T m_t;
  MyExample(const T& t);
  T get();
  void set(const T& t);
};

c.cpp

template<typename T>
MyExample<T>::MyExample(const T& t) : m_t(t) {}
template<typename T>
T MyExample<T>::get() { return m_t; }
template<typename T>
void MyExample<T>::set(const T& t) { m_t = t; }

a.cpp

 #include "c.h" // only need interface
 #include <iostream>
 int main() {
   MyExample<int> x(10);
   std::cout << x.get() << std::endl;
   x.set( 9 );
   std::cout << x.get() << std::endl;
   return EXIT_SUCCESS;
 }

b.cpp, "библиотеке":

 #include "c.h" // need interface
 #include "c.cpp" // need implementation to actually instantiate it
 template class MyExample<int>;

Теперь Вы компилируете b.cpp в b.o однажды. Когда a.cpp изменяет Вас, просто должен перекомпилировать это и ссылку в b.o.