Focusing mainly on the hash-table:

The main reason for using a hash-table-like data structure is to get constant-time (or near constant) lookup. When you decided to use a linked list for the backing-store of your hash-table, you lost that benefit. indexOfKey() is linear time. I would just throw that list out and use a std::vector as the backing store. Then there are several strategies you can use to resolve collisions. You can find an overview of each on Wikipedia.

If you're interested in leaning templates, use them for the table. Why limit it to integers only? The key type in a hash-table is often a string, but again, you don't have to be limited to that, the key type could also be templated.

I question the necessity for the hashmap_ function pointer and this:

int hashmap(int prehashedKey, int tableSize)
{
    return prehashedKey % tableSize;
}

Is there any other way to index into a hash-table other than the modulo operator? Not that I know of. I mean, you could use key & (size - 1) if the size is known to be power-of-two, but that's a micro optimization that the compiler is probably already doing. Remove that extra member function pointer and use % directly. It will make your code clearer and faster.

The hash function, which you call prehash_, could also be a template parameter. Take a leaf out of the C++ Standard Library's book, make it compatible with std::hash and you won't even have to provide a custom hasher for common types like integers and strings.

All in all, your HashTable should be looking something like this:

template
<
    class Key,
    class Val,
    class Hasher = std::hash<Key>
>
class HashTable
{
public:
    // your interface...

private:
    std::vector<Val> buckets;
};

Since the hasher is resolved at compiler time, you don't even need to store a copy of it, you can instantiate directly when applying it on a key:

static std::size_t hashOf(const Key & key)
{
    return Hasher{}(key);
}

Other general details and guidelines:

• When you're taking a potentially large object, such as a std::string, in a function parameter, and the function is only looking at the object without copying it, pass by const reference to avoid the copy. E.g.:

  bool search(const std::string & key) { ...
              ^^^^^             ^
  

  Simple types like integers can be passed by value, of course. The hardware has built-in registers for those.

• const on a return type (const bool search(std::string key) const) is meaningless at best, but can prevent optimal code from being generated if applied to objects. Don't get into the habit of doing that.

• Node and LLNode seems like gratuitous obfuscation. Just make Node an inner private class of the linked list. No need at all for it to be a public type. Also, just leave next publicly visible. Having a get/set pair is just a verbose way of defining a public variable.

• Don't assign zero to pointers (like in here LLNode<T>* pp = 0;), not anymore, at least. Now there's the nullptr literal (since C++11).

Regarding class hierarchy and inheritance:

I'm not really convinced about the reasoning why you need to have that extra LLNode<T> derived from Node<T> instead of just LLNode<T> and simply merge these classes.

An indication this seems useless, is that you never use Node<T> anywhere else, but just for inheritance.

 template<class T>
 class LinkedList : public Stack<T> {

I don't understand this. A Stack might be a specialization of a LinkefList, not vice versa.

It's not the point for OOP design, to put smallest pieces of data structure operation policies into base classes, and derive just straight forward up to the final class structure.

What you want is guaranteed interfaces regarding several aspects, but keep them in separate constraints and base classes.

To detect constraint violations early, use SFINAE techniques.

Also you might want to get informed about mixins and the CRTP.

Code changes

• I changed HashTable to a template class as suggested.

• The hashmap constructor argument is now an optional argument with default value given by the unsigned modulo operator.

• I have also implemented table doubling/halving.

• I found comparable performance with std::unordered_set<std::string> by inserting 58,110 english words.

Results

Inserting into hash table...

Insertion time: 0.132802

Load factor: 0.886688

Number of buckets: 65536

Longest chain: 7

Inserting into unordered_set...

Insertion time: 0.095464

Load factor: 0.564849

Longest chain: 6

// a basic hash table class where the items are equivalent to the keys

static int defaultMap(int val, int mod)
{
    // always non-negative
    return ((val % mod) + mod) % mod;
}

template<class Key, class Prehasher = std::hash<Key> >
class HashTable {
public:
    // constructor
    HashTable(int tableSize = 1, int (*hashmap)(int val, int mod) = defaultMap);
    ~HashTable() { delete[] table_; }
    // dictionary operations
    bool search(const Key& key) const;
    void insert(const Key& key);
    void del(const Key& key);
    void printTable() const;
    double load_factor() const { return (double)numElements_/tableSize_; }
    int bucket_count() const { return tableSize_; }
    int bucket_size(int i) const { return table_[i].getSize(); }
    // rebuilds table with size m
    void rebuild(int m);
private:
    void insertPrivate(const Key& key);
    // prehash function
    int prehashOf(const Key& key) const { return Prehasher()(key); };
    // function pointer for hash map
    int (*hashmap_)(int phKey, int m);
    int tableSize_;
    int numElements_;
    LinkedList<Key>* table_;
};

template<class Key, class Prehasher> HashTable<Key, Prehasher>::HashTable(int tableSize,
                     int (*hashmap)(int phKey, int m))
: hashmap_(hashmap), tableSize_(tableSize)
{
    table_ = new LinkedList<Key>[tableSize];
}

template<class Key, class Prehasher> void HashTable<Key, Prehasher>::rebuild(int m)
{
    // create an array on the heap to store the new table of size m
    LinkedList<Key>* newTable = new LinkedList<Key>[m];
    // create a pointer to the old table
    LinkedList<Key>* oldTable = table_;
    int oldSize = tableSize_;
    // resassign member variable of HashTable
    table_ = newTable;
    tableSize_ = m;

    // fill the new table
    for(int i=0; i<oldSize; i++)
    {
        while( oldTable[i].getSize()!=0 )
        {
            insertPrivate( oldTable[i].top() );
            oldTable[i].pop();
        }
    }
    delete[] oldTable;
}

template<class Key, class Prehasher> bool HashTable<Key, Prehasher>::search(const Key& key) const
{
    // compute the slot associated with the key
    int phKey = prehashOf(key);
    int slot = (*hashmap_)(phKey, tableSize_);
    // search the linked list for phKey
    int idx = table_[slot].indexOfKey(key);
    bool isThere = false;
    if(idx != -1) isThere = true;
    return isThere;
}

template<class Key, class Prehasher>void HashTable<Key, Prehasher>::insertPrivate(const Key& key)
{

    int phKey = prehashOf(key);
    int slot = (*hashmap_)(phKey, tableSize_);
    // push the item into the linked list
    table_[slot].push(key);
}

template<class Key, class Prehasher>void HashTable<Key, Prehasher>::insert(const Key& key)
{
    if(numElements_+1 > tableSize_) rebuild(2*tableSize_);
    // compute the slot associated with the key
    int phKey = prehashOf(key);
    int slot = (*hashmap_)(phKey, tableSize_);
    // search the linked list for phKey
    int idx = table_[slot].indexOfKey(key);
    if(idx == -1)
    {
        // push the item into the linked list
        table_[slot].push(key);
        ++numElements_;
    }
    else
    {
        std::cout << "Hash table already contains target key " << key << "\n";
    }
}

template<class Key, class Prehasher> void HashTable<Key, Prehasher>::del(const Key& key)
{
    if(numElements_-1 < tableSize_/4) rebuild(tableSize_/2);
    // compute the slot associated with the key
    int phKey = prehashOf(key);
    int slot = (*hashmap_)(phKey, tableSize_);
    // search the linked list for phKey
    int idx = table_[slot].indexOfKey(key);
    if(idx != -1)
    {
        // delete node at index idx
        table_[slot].deleteNode(idx);
        --numElements_;
    }
    else
    {
        std::cout << "Hash table does not contain target key.\n";
    }
}

template<class Key, class Prehasher> void HashTable<Key, Prehasher>::printTable() const
{
    for(int i=0; i < tableSize_; i++)
    {
        std::cout << i << ": ";
        table_[i].printList();
        std::cout << std::endl;
    }
}