C++类中键-值列表向量函数实现求助

Hey there! Let's work through this problem together. It sounds like you need to keep a strict 1:1 index mapping between your keys vector and values vector—so every key at position i in keys lines up perfectly with the list of integers at position i in values. That's a common pattern, and there are straightforward ways to make sure you don't mess up the index alignment.

The Core Rule: Keep Vectors Synced at All Times #

The biggest risk here is accidentally modifying one vector without updating the other, which breaks the index link. The best way to avoid this is to manage both vectors together instead of treating them as separate entities.

1. Add Keys and Initialize Value Lists in Pairs #

Instead of filling all keys first and then trying to match up the values, add each key and immediately create an empty corresponding list in values. This guarantees their sizes stay identical from the start.

Here's a code example for your class:

#include <vector>
#include <list>
#include <algorithm>
#include <stdexcept>

template <typename KeyType>
class KeyValueStore {
private:
    std::vector<KeyType> keys;
    std::vector<std::list<int>> values;

public:
    // Add a key and create an empty list for its values
    void addKey(const KeyType& key) {
        keys.push_back(key);
        values.emplace_back(); // Inserts an empty list<int> at the end
    }

    // Add an integer value to the list associated with a specific key
    bool addValueToKey(const KeyType& key, int value) {
        // Find the position of the key
        auto keyIter = std::find(keys.begin(), keys.end(), key);
        if (keyIter == keys.end()) {
            return false; // Key doesn't exist, return failure
        }

        size_t index = std::distance(keys.begin(), keyIter);
        values[index].push_back(value);
        return true;
    }

    // If you know the index (e.g., for bulk filling), add directly by index
    void addValueByIndex(size_t index, int value) {
        if (index >= keys.size()) {
            throw std::out_of_range("Index exceeds number of keys");
        }
        values[index].push_back(value);
    }
};

2. If You Already Filled keys First: Sync values Size #

If you've already populated the keys vector and need to set up values to match, start by resizing values to match the size of keys. This creates empty lists for every existing key, so you can safely fill them by index:

// Assuming keys is already filled with your KeyType elements
values.resize(keys.size()); // Now values has the same number of empty lists as keys

// Example: Fill values for the first key
values[0].push_back(10);
values[0].push_back(20);

// Fill values for the second key
values[1].push_back(30);

3. When Removing Elements: Delete from Both Vectors #

If you ever need to remove a key, make sure you delete the corresponding value list at the same index:

void removeKey(size_t index) {
    if (index >= keys.size()) {
        return; // Avoid out-of-bounds errors
    }
    keys.erase(keys.begin() + index);
    values.erase(values.begin() + index);
}

Quick Tips to Avoid Mistakes #

• Never call push_back() on keys without also adding an element to values (and vice versa).
• If you're using loops to fill values, always iterate based on the size of keys (not values) to ensure you don't go out of bounds.
• For better performance (if your keys are unique and you do frequent lookups), consider adding a std::unordered_map<KeyType, size_t> to map keys to their indices—this avoids using std::find every time you need to add a value.

内容的提问来源于stack exchange，提问作者ASaha