键值对(key-value pair)表中存储的是一个个键值对，如table[2016]=19.5表示该表中有一项的key为2016，其value为19.5。我们需要管理的表中， key为整数，而value可为浮点数，整数或字符。所以我们定义一个类模板，得到了三个相应的模板类。 键值对表的容量是有限的，当表中存储的key的数量达到上限时，将不存入新的键值对，但对表中已有的key仍然会继续更新其value。每行输入有三项，第一项是类型（1为浮点数，2为整数，3为字符），第二项是key，第三项是value。在处理完每行输入后，如果输入的类型信息合法，则会输出当前该类型的键值表中最小的value及其key。对于整数和字符表，若干个键值对的value值可能相同，此时输出key最小的那一项。

以下是一个示例的类模板实现，包含三个模板类：PairTable、IntPairTable、CharPairTable。

#include <map>
#include <iostream>
#include <limits>

template<typename KeyType, typename ValueType>
class PairTable {
public:
    void insert(KeyType key, ValueType value) {
        if (m_table.size() < m_capacity) {
            m_table[key] = value;
        } else if (m_table.find(key) != m_table.end()) {
            m_table[key] = value;
        }
    }

    bool empty() const {
        return m_table.empty();
    }

    void printSmallestValue() const {
        if (m_table.empty()) {
            std::cout << "null" << std::endl;
            return;
        }

        auto smallest = m_table.begin();
        for (auto it = m_table.begin(); it != m_table.end(); ++it) {
            if (it->second < smallest->second ||
                (it->second == smallest->second && it->first < smallest->first)) {
                smallest = it;
            }
        }

        std::cout << smallest->second << " " << smallest->first << std::endl;
    }

    PairTable(int capacity) : m_capacity(capacity) {}

private:
    std::map<KeyType, ValueType> m_table;
    int m_capacity;
};

template<typename KeyType>
class IntPairTable : public PairTable<KeyType, int> {
public:
    IntPairTable(int capacity) : PairTable<KeyType, int>(capacity) {}
};

template<typename KeyType>
class CharPairTable : public PairTable<KeyType, char> {
public:
    CharPairTable(int capacity) : PairTable<KeyType, char>(capacity) {}

    void insert(KeyType key, char value) {
        if (this->m_table.size() < this->m_capacity) {
            this->m_table[key] = value;
        } else if (this->m_table.find(key) != this->m_table.end()) {
            this->m_table[key] = value;
        }
    }

    void printSmallestValue() const {
        if (this->m_table.empty()) {
            std::cout << "null" << std::endl;
            return;
        }

        int smallest_key = std::numeric_limits<int>::max();
        char smallest_value = std::numeric_limits<char>::max();
        for (auto it = this->m_table.begin(); it != this->m_table.end(); ++it) {
            if (it->second < smallest_value ||
                (it->second == smallest_value && it->first < smallest_key)) {
                smallest_key = it->first;
                smallest_value = it->second;
            }
        }

        std::cout << static_cast<int>(smallest_value) << " " << smallest_key << std::endl;
    }
};

使用示例：

int main() {
    int capacity;
    std::cin >> capacity;

    IntPairTable<int> int_table(capacity);
    PairTable<int, double> double_table(capacity);
    CharPairTable<int> char_table(capacity);

    int type, key_i;
    double value_d;
    char value_c;
    while (std::cin >> type >> key_i) {
        switch (type) {
        case 1:
            std::cin >> value_d;
            double_table.insert(key_i, value_d);
            break;
        case 2:
            std::cin >> value_i;
            int_table.insert(key_i, value_i);
            break;
        case 3:
            std::cin >> value_c;
            char_table.insert(key_i, value_c);
            break;
        default:
            break;
        }
    }

    int_table.printSmallestValue();
    double_table.printSmallestValue();
    char_table.printSmallestValue();

    return 0;
}