尝试用数组设计一个模板类template<typename key_type,typename value_type > class map;map包含以下成员：map中表示键值对的结构体：struct instance {key_value key; value_type value };map中存储的instance指针数组：instance **INSTANCES;map的最大容量：int map_size;map中需要实现的函数：（1）map(int N); 函数的作用：map_size赋值为 N；利用map_size初始化数组INSTANCES，数组每个元素赋值 nullptr。（2）instance* search(key_value k)；函数的作用：顺序遍历查找INSTANCES中是否有 k 对应的instance，若有，返回一个指向该instance的指针，否则返回 nullptr 。（3）void set(key_value real_key, value_type real_value);函数的作用：将 (real_key，real_value) 插入到INSTANCES中，插入的方式为：【1】首先调用函数 search(real_key)，假设返回值为 res，如果 res 不是nullptr；那么说明此时 real_key 已经在 map 中对应了一个键值对，此时你需要修改 res 所指向对象的 value 为 real_value【2】若 【1】 中 res == nullptr，则你需要插入一个键值对；插入方式为：按照顺序遍历INSTANCES，当遍历第 i 个元素 INSTANCES[i] == nullptr时，利用参数real_key 和 real_value初始化一个 instance对象 , INSTANCES[i]指向该instance对象【3】若map满了，则打印出错（4）value_type* get(key_value k);函数的作用：调用 search 函数，查找 k 对应的 value，打印查找成功并返回一个指向 value 的指针；如果没有找到，返回nullptr（5）void delete(key_value k);函数的作用：顺序遍历查找INSTANCES中是否有 k 对应的instance，若有则释放掉

好的，让我们来一步步实现这个模板类 map。

首先，我们需要定义 map 类和 instance 结构体，并声明一些成员变量和函数。根据题目要求，我们需要一个指向 instance 的指针数组 INSTANCES 和 map 的最大容量 map_size。

template<typename key_type, typename value_type>
class map {
public:
    struct instance {
        key_type key;
        value_type value;
    };
    instance **INSTANCES;
    int map_size;

    map(int N);
    instance* search(key_type k);
    void set(key_type real_key, value_type real_value);
    value_type* get(key_type k);
    void del(key_type k);
};

接下来，我们需要实现构造函数 map(int N)，这个函数的作用是将 map_size 赋值为 N，并初始化 INSTANCES 数组，将每个元素赋值为 nullptr。

template<typename key_type, typename value_type>
map<key_type, value_type>::map(int N) {
    map_size = N;
    INSTANCES = new instance*[map_size];
    for (int i = 0; i < map_size; i++) {
        INSTANCES[i] = nullptr;
    }
}

接着，我们需要实现 search 函数，这个函数的作用是顺序遍历查找 INSTANCES 中是否有 k 对应的 instance，若有，返回一个指向该 instance 的指针，否则返回 nullptr。

template<typename key_type, typename value_type>
typename map<key_type, value_type>::instance* map<key_type, value_type>::search(key_type k) {
    for (int i = 0; i < map_size; i++) {
        if (INSTANCES[i] != nullptr && INSTANCES[i]->key == k) {
            return INSTANCES[i];
        }
    }
    return nullptr;
}

然后，我们需要实现 set 函数，这个函数的作用是将 (real_key, real_value) 插入到 INSTANCES 中。首先，我们需要调用 search 函数查找是否已经存在 key 为 real_key 的 instance。如果已经存在，我们需要修改该 instance 的 value 为 real_value。如果不存在，我们需要按照顺序遍历 INSTANCES，找到第一个为 nullptr 的元素，利用参数 real_key 和 real_value 初始化一个 instance 对象，然后将该元素指向该 instance 对象。如果 map 已满，则打印出错。

template<typename key_type, typename value_type>
void map<key_type, value_type>::set(key_type real_key, value_type real_value) {
    instance *res = search(real_key);
    if (res != nullptr) {
        res->value = real_value;
    } else {
        int i = 0;
        while (i < map_size && INSTANCES[i] != nullptr) {
            i++;
        }
        if (i < map_size) {
            INSTANCES[i] = new instance;
            INSTANCES[i]->key = real_key;
            INSTANCES[i]->value = real_value;
        } else {
            std::cout << "Map is full." << std::endl;
        }
    }
}

接下来，我们需要实现 get 函数，这个函数的作用是调用 search 函数，查找 k 对应的 value，打印查找成功并返回一个指向 value 的指针；如果没有找到，返回 nullptr。

template<typename key_type, typename value_type>
value_type* map<key_type, value_type>::get(key_type k) {
    instance *res = search(k);
    if (res != nullptr) {
        std::cout << "Find the value of key " << k << ": " << res->value << std::endl;
        return &(res->value);
    } else {
        return nullptr;
    }
}

最后，我们需要实现 del 函数，这个函数的作用是顺序遍历查找 INSTANCES 中是否有 k 对应的 instance，若有则释放掉。

template<typename key_type, typename value_type>
void map<key_type, value_type>::del(key_type k) {
    instance *res = search(k);
    if (res != nullptr) {
        delete res;
        res = nullptr;
    }
}

到此为止，我们已经完成了这个模板类 map 的实现。现在你可以在自己的代码中使用它，例如：

map<int, std::string> my_map(10);
my_map.set(1, "hello");
my_map.set(2, "world");
my_map.get(1);
my_map.get(2);
my_map.del(1);
my_map.get(1);