C++ 使用std:：map的递归堆栈分配是如何工作的？

具有自身内部引用的堆栈分配容器如何知道何时分配其子容器

例如：

class Trie {
    public:
    struct Node {
        map<char, Node> letters;
        bool end;
    };

    Node root;

    /** Initialize your data structure here. */
    Trie() {

    }

    /** Inserts a word into the trie. */
    void insert(string word) {
        Node *iter = &root;
        for(auto c: word) {
            iter = &iter->letters[c];
        }
        iter->end = true;
    }

    /** Returns if the word is in the trie. */
    bool search(string word) {
        Node *iter = &root;
        for(auto c: word) {
            if(iter->letters.find(c) == iter->letters.end()) return false;
            iter = &iter->letters[c];
        }
        return iter->end;
    }

    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        Node *iter = &root;
        for(auto c: prefix) {
            if(iter->letters.find(c) == iter->letters.end()) return false;
            iter = &iter->letters[c];
        }
        return true;
    }
};

class-Trie{
公众：
结构节点{
地图字母；
布尔端；
};
节根；
/**在这里初始化数据结构*/
Trie（）{
}
/**在trie中插入一个单词*/
空白插入（字符串字）{
节点*iter=&root；
用于（自动c:word）{
iter=&iter->字母[c]；
}
iter->end=true；
}
/**如果单词在trie中，则返回*/
布尔搜索（字符串字）{
节点*iter=&root；
用于（自动c:word）{
如果（iter->letters.find（c）=iter->letters.end（））返回false；
iter=&iter->字母[c]；
}
返回iter->end；
}
/**返回trie中是否有以给定前缀开头的单词*/
bool startsWith（字符串前缀）{
节点*iter=&root；
用于（自动c:前缀）{
如果（iter->letters.find（c）=iter->letters.end（））返回false；
iter=&iter->字母[c]；
}
返回true；
}
};

这段代码有效，但我不完全确定为什么。（这是我对LeetCode上Trie问题的解决方案。）

---

我有一个简单的堆栈分配根

节点

，它包含

字符

->

节点

的映射。我的问题是，何时实际分配子节点？在

字母下有对节点的引用时，是否会发生这种情况？（
iter=&iter->letters[c]；
）这段代码是不是非常不正确，并且对未定义的行为做了太多假设？
std:：map:：operator[]
允许您在密钥不在容器中的情况下使用
map[key]=value
的语义。想象一下，如果使用大小为
n
的
std:：vector
：如果调用
v[v.size（）]
，那么至少可以说，该引用是指向无主内存。如果您想拥有它，您必须首先调整容器的大小，以确保键（索引）在容器的范围内

因此，当您调用
操作符[]
时，容器将检查您的密钥是否存在，如果它不存在，则默认为它构造一个值，然后返回对它的引用，就像它一直存在一样。这就是为什么
操作符[]
是一个变异函数；如果密钥不存在，则在分配和默认构造新值后，容器的状态将发生变化。
std:：map:：operator[]
允许您在密钥不在容器中的情况下使用
map[key]=value
的语义。想象一下，如果使用大小为
n
的
std:：vector
：如果调用
v[v.size（）]
，那么至少可以说，该引用是指向无主内存。如果您想拥有它，您必须首先调整容器的大小，以确保键（索引）在容器的范围内

因此，当您调用
操作符[]
时，容器将检查您的密钥是否存在，如果它不存在，则默认为它构造一个值，然后返回对它的引用，就像它一直存在一样。这就是为什么
操作符[]
是一个变异函数；如果该键不存在，则在分配和默认构造新值后，容器的状态将发生变化。
诀窍在于
字母[c]
。阅读
std:：map:：operator[]（const Key&）
的功能。诀窍在于
字母[c]
。了解
std:：map:：operator[]（const Key&）
的功能。