template<class T> class Catalog : public map<T, pair<int, int> > {
    public:
    Catalog();
    void loadFromFile(string);
...
};

template<class T> void Catalog<T>::loadFromFile(string filename) {
    ifstream datafile(filename.c_str());
    if (!datafile){
    throw runtime_error("Can not load data from file " + filename);
    }

    T item;
    int itemcount, itemtaken;
    while (!datafile.eof()) {
    datafile >> item; //274 строка
    datafile >> itemcount >> itemtaken;
    map<T, pair<int, int> >::insert(make_pair(item, make_pair(itemcount, itemtaken)));
    }
    datafile.close();
}

#include <utility>
#include <map>
#include <fstream>
#include <stdexcept>
#include <string>

struct streamable
{
  int key_;
};

::std::ifstream &
operator>>( ::std::ifstream & s, streamable & d )
{
  s >> d.key_;
  return( s );
}

bool
operator<( streamable const & lhs, streamable const & rhs )
{
  return( lhs.key_ < rhs.key_ );
}

template< class T >
class Catalog
  : public ::std::map< T, ::std::pair<int, int> >
{
  public:

    Catalog( void )
    {}

    void loadFromFile( ::std::string filename )
    {
      ::std::ifstream datafile( filename.c_str() );
      if( !datafile )
        throw ::std::runtime_error( "Can not load data from file " + filename );

      T item;
      int itemcount, itemtaken;
      while( !datafile.eof( ) )
      {
        datafile >> item; //274 строка
        datafile >> itemcount >> itemtaken;
        this->insert( ::std::make_pair( item, ::std::make_pair( itemcount, itemtaken ) ) );
      }
    }
};


int main( void )
{
  Catalog< streamable > test;
  test.loadFromFile( "test.txt" );
}

A_A>Error E2015 VideoRent.cpp 274: Ambiguity between 'istream::operator >>(bool &)'
A_A> and 'istream::operator >>(void * &)'
A_A> in function Catalog<VideoRecord *>::loadFromFile(string)
A_A>*** 1 errors in Compile ***

class VideoRecord {
...
friend ifstream& operator>> (ifstream& input, VideoRecord& record) {
    input.getline(title, sz);
    input.getline(year, sz);
    input.getline(producer, sz);
    input.getline(genre, sz);
    input.getline(country, sz);

    record.setTitle(title);
    record.setYear(atoi(year));
    record.setProducer(producer);
    record.setGenre(genre);
    record.setCountry(country);
}
...
};

template<class T> void Catalog<T>::loadFromFile(string filename) {
    ifstream datafile(filename.c_str());
    if (!datafile){
    throw runtime_error("Can not load data from file " + filename);
    }

    T item();
    
    int itemcount, itemtaken, stop;
    char buffer[128];
    while (!datafile.eof()) {
    datafile >> *item; //395 строка


    datafile.getline(buffer, 128);
    itemcount = atoi(buffer);
    memset(buffer, 0, 128);
    datafile.getline(buffer, 128);
    itemtaken = atoi(buffer);
    memset(buffer, 0, 128);

    map<T, pair<int, int> >::insert(make_pair(item, make_pair(itemcount, itemtaken)));
    }
    datafile.close();
}

A_A>Немного переделал код и терерь ошибки совсем другие

A_A>class VideoRecord {
A_A>...
A_A>friend ifstream& operator>> (ifstream& input, VideoRecord& record) {
A_A>    input.getline(title, sz);
A_A>    input.getline(year, sz);
A_A>    input.getline(producer, sz);
A_A>    input.getline(genre, sz);
A_A>    input.getline(country, sz);

A_A>    record.setTitle(title);
A_A>    record.setYear(atoi(year));
A_A>    record.setProducer(producer);
A_A>    record.setGenre(genre);
A_A>    record.setCountry(country);
A_A>}
A_A>...
A_A>};

A_A>template<class T> void Catalog<T>::loadFromFile(string filename) {
    // где T - это VideoTape* или DVD*, то есть это некий указатель
A_A>    ifstream datafile(filename.c_str());
A_A>    if (!datafile){
A_A>    throw runtime_error("Can not load data from file " + filename);
A_A>    }

A_A>    T item();
        // здесь ты объявил функцию item без параметров, возвращающую T
    
A_A>    int itemcount, itemtaken, stop;
A_A>    char buffer[128];
A_A>    while (!datafile.eof()) {
A_A>    datafile >> *item; //395 строка
        // естественно, что istream не знает, как можно вывести что-то в разыменованный указатель на функцию
        // (имя функции имеет тип указателя на функцию)

A_A>    datafile.getline(buffer, 128);
A_A>    itemcount = atoi(buffer);
A_A>    memset(buffer, 0, 128);
A_A>    datafile.getline(buffer, 128);
A_A>    itemtaken = atoi(buffer);
A_A>    memset(buffer, 0, 128);

A_A>    map<T, pair<int, int> >::insert(make_pair(item, make_pair(itemcount, itemtaken)));
        // и здесь - попытка добавить пару, у которой first - это укзатель на функцию
A_A>    }
A_A>    datafile.close();
A_A>}

PointerType item = NULL;
// или
PointerType item = PointerType();
// или
ObjectType item; // вот тут твой пустой конструктор пригодится

template<class ObjectType>
class Catalog
{
private:
    typedef std::map<ObjectType*, std::pair<int,int> > map_type;
    map_type m_data;
public:
    // а здесь - только те операции из map, которые можно публиковать.
    // плюс свои операции
    
    // в крайнем случае, можно выдавать map наружу
    map_type& data() { return m_data; }
    map_type const& data() const { return m_data; }
};