Looking at this code, I have several remarks, let me start with your questions:

Is my create member function idiomatic?

No, I barely see it. Mostly because it doesn't add value. Either classes are small enough so it doesn't matter, or copy/assign ain't supported, or it can be defaulted.

In this case, it looks better to have a virtual method clone on the nose or make the structure templated (preferred by me).

Is there a way that I could avoid using the virtual function get_word?

In general I would make the node type would be a template argument, yes. Otherwise, you could cast (similar to CRTP), however that requires knowledge of the available types. For this specific case, I realize this ain't possible, however, it does make sense having only one node.

Ownership

You have some memory leaks in your code. I suggest to use a simple rule of thumb: always use unique_ptr instead of new/delete. Or when possible, just store by value in the map.

Relevance of member functions

prefix_apply is a very good example of a function that should be a free function. You make a copy and adapt the whole structure. Why not build up a new map?

At the same time, it is very specific, so you could replace it by the visitor pattern.

Rule of five

Applying the rule of five allows you to move instead of copying. Most of the time, I even write move operations with the copy variant deleted.

Public members

Just don't, this is very hard to maintain. Especially when you encounter a specific implementation is buggy.

Purpose and performance

It looks like you are trying to make an ever growing string pool in which you want to share strings. How about using std::unordered_set or just a vector on which to unique/erase. Both variants will be more memory efficient and most like more performant.

Here's an updated version that I made with the help of the answers JVApen and hoffmale posted.

Instead of storing the full string in terminal Trie nodes (this can actually increase the space complexity e.g. for the case of a unary tree), I modified prefix_apply to generate this strings as needed. This also lets us do away with the inheritance.

unique_ptr can take care of all the memory management.

I added an erase member function.

Definitely a big improvement! Thanks for the help!

#include <utility>
#include <map>
#include <string>
#include <iostream> // for example usage


struct TrieNode {
    // unique_ptr + trees are a great match since every vertex has a unique parent
    std::map<char, std::unique_ptr<TrieNode>> children;
};

class Trie {
private:
    TrieNode root;

    TrieNode const* find(std::string const& w) const  {
        // Return a pointer to the TrieNode for the last character in w, or nullptr if it doesn't exist.
        TrieNode const* node = &root;
        for (char const c: w) {
            auto const it = node->children.find(c);
            if (it != node->children.end()) {
                node = it->second.get();
            } else return nullptr;
        }
        return node;
    }

    template<typename StringFunction>
    void prefix_apply_helper(TrieNode const* node, std::string& w, StringFunction& f) const{
        // Recursively apply f to all strings at or beneath node in the Trie.
        // w should be the (possibly incomplete) word represented by node.
        if (node->children.find('\0') != node->children.end())
            f(w);
        for (auto const& cw: node->children) {
            if (cw.first != '\0') {
                w.push_back(cw.first);
                prefix_apply_helper(cw.second.get(), w, f);
                w.pop_back();
            }
        }
    }
public:
    void insert(std::string const& w) {
        // Insert a word into the Trie.
        TrieNode* node = & root;
        for (char const c: w) {
            auto const it = node->children.find(c);
            if (it != node->children.end()) {
                node = it->second.get();
            } else {
                auto* new_node = new TrieNode();
                node->children[c] = std::unique_ptr<TrieNode>(new_node);
                node = new_node;
            }
        }
        node->children['\0'];
    }

    bool contains(std::string const& w) const {
        // Check if the Trie contains the word
        auto const* node = find(w);
        if (node)
            return node->children.find('\0') != node->children.end();
        else return false;
    }

    void erase(std::string const& w) {
        // Remove the word from the Trie.
        TrieNode* node = &root;
        bool one_child_chain = false;
        TrieNode* one_child_chain_start = nullptr;
        char one_child_chain_first = '\0';

        for (char const c: w) {
            auto const it = node->children.find(c);
            if (it != node->children.end()) {
                if (!one_child_chain && it->second->children.size() == 1) {
                    one_child_chain = true;
                    one_child_chain_start = node;
                    one_child_chain_first = c;
                } else if (it->second->children.size() != 1) {
                    one_child_chain = false;
                }
                node = it->second.get();
            } else return;
        }
        node->children.erase('\0');
        if (one_child_chain)
            one_child_chain_start->children.erase(one_child_chain_first);

    }

    template<typename StringFunction>
    void prefix_apply(std::string prefix, StringFunction& f) const {
        // Apply f to every word in the Trie that has the given prefix
        auto const* node = find(prefix);
        if (node)
            prefix_apply_helper(node, prefix, f);
    }
};

int main(int argc, const char * argv[]) {
    Trie t;
    t.insert("apple");
    t.insert("app");
    t.insert("appalachians");
    t.insert("banana");
    t.erase("appalachians");
    t.insert("appalled");
    t.prefix_apply("app", [](std::string const& w) { std::cout << w << '\n'; });
}