C++ 数字误差的素数分解

我制作了一个函数，返回一个包含整数所有素数因子的

向量，我正在尝试制作另一个函数，从该
向量创建一个
映射

然而，我得到一些非法内存访问错误，我无法找到它是什么。我认为它发生在
映射factorzacion（vector）
函数的
for
循环中

我希望我能在这里得到一些帮助

我可以发布整个程序，但我会坚持使用导致问题的函数。如果您需要查看，只需询问代码的其余部分即可

map<int, int> factorizacion(vector<int> v) {
    map<int, int> m;

    while (!v.empty()) {
        int elto = v.front();
        int ctd = 0;

        for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
            if (*it == elto) {
                ++ctd;
                v.erase(it);
            }
        }
        m[elto] = ctd;
    }

    return m;
}

map factorzacion（向量v）{
地图m；
而（！v.empty（））{
int elto=v.front（）；
int-ctd=0；
for（vector:：iterator it=v.begin（）；it！=v.end（）；++it）{
如果（*it==elto）{
++ctd；
v、 抹去（它）；
}
}
m[elto]=ctd；
}
返回m；
}
修改迭代的集合：

for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
    if (*it == elto) {
        ++ctd;
        v.erase(it);
    }
}

唯一的问题是我的解决方案在性能方面有点慢——它执行的查询比最佳解决方案多。然而，我提出的解决方案比你的更好（当它得到修复时，因为）：


向量中的擦除操作成本高昂，需要线性时间，性能比我的
map
tweak差得多
我不改变方法的参数。我知道它不是通过引用传递的，但在可能的情况下，最好不要影响参数
修改迭代的集合：

for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
    if (*it == elto) {
        ++ctd;
        v.erase(it);
    }
}

唯一的问题是我的解决方案在性能方面有点慢——它执行的查询比最佳解决方案多。然而，我提出的解决方案比你的更好（当它得到修复时，因为）：


向量中的擦除操作成本高昂，需要线性时间，性能比我的
map
tweak差得多
我不改变方法的参数。我知道它不是通过引用传递的，但在可能的情况下，最好不要影响参数
修改迭代的集合：

for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
    if (*it == elto) {
        ++ctd;
        v.erase(it);
    }
}

唯一的问题是我的解决方案在性能方面有点慢——它执行的查询比最佳解决方案多。然而，我提出的解决方案比你的更好（当它得到修复时，因为）：


向量中的擦除操作成本高昂，需要线性时间，性能比我的
map
tweak差得多
我不改变方法的参数。我知道它不是通过引用传递的，但在可能的情况下，最好不要影响参数
修改迭代的集合：

for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
    if (*it == elto) {
        ++ctd;
        v.erase(it);
    }
}

唯一的问题是我的解决方案在性能方面有点慢——它执行的查询比最佳解决方案多。然而，我提出的解决方案比你的更好（当它得到修复时，因为）：


向量中的擦除操作成本高昂，需要线性时间，性能比我的
map
tweak差得多
我不改变方法的参数。我知道它不是通过引用传递的，但在可能的情况下，最好不要影响参数
v.擦除（它）
使
无效。您需要更改循环：

for (vector<int>::iterator it = v.begin(); it != v.end();) {
    if (*it == elto) {
        ++ctd;
        it = v.erase(it);
    } else {
       ++it;
    }
}

for（vector:：iterator it=v.begin（）；it！=v.end（）；）{
如果（*it==elto）{
++ctd；
它=v.擦除（它）；
}否则{
++它；
}
}

或者更好地使用
std:：remove
和
.erase
类似于“erase-remove”习惯用法。我不会在这里重复，因为你可以查一下。可以将计数计算为两个迭代器之间的差值

或者更好的方法是，在不删除它们的情况下计算因子，就像Niklas的评论一样。
v.erase（it）
使
it
无效。您需要更改循环：

for (vector<int>::iterator it = v.begin(); it != v.end();) {
    if (*it == elto) {
        ++ctd;
        it = v.erase(it);
    } else {
       ++it;
    }
}

for（vector:：iterator it=v.begin（）；it！=v.end（）；）{
如果（*it==elto）{
++ctd；
它=v.擦除（它）；
}否则{
++它；
}
}

或者更好地使用
std:：remove
和
.erase
类似于“erase-remove”习惯用法。我不会在这里重复，因为你可以查一下。可以将计数计算为两个迭代器之间的差值

或者更好的方法是，在不删除它们的情况下计算因子，就像Niklas的评论一样。
v.erase（it）
使
it
无效。您需要更改循环：

for (vector<int>::iterator it = v.begin(); it != v.end();) {
    if (*it == elto) {
        ++ctd;
        it = v.erase(it);
    } else {
       ++it;
    }
}

for（vector:：iterator it=v.begin（）；it！=v.end（）；）{
如果（*it==elto）{
++ctd；
它=v.擦除（它）；
}否则{
++它；
}
}

或者更好地使用
std:：remove
和
.erase
类似于“erase-remove”习惯用法。我不会在这里重复，因为你可以查一下。可以将计数计算为两个迭代器之间的差值

或者更好的方法是，在不删除它们的情况下计算因子，就像Niklas的评论一样。
v.erase（it）
使
it
无效。您需要更改循环：

for (vector<int>::iterator it = v.begin(); it != v.end();) {
    if (*it == elto) {
        ++ctd;
        it = v.erase(it);
    } else {
       ++it;
    }
}

for（vector:：iterator it=v.begin（）；it！=v.end（）；）{
如果（*it==elto）{
++ctd；
它=v.擦除（它）；
}否则{
++它；
}
}

或者更好地使用
std:：remove
和
.erase
类似于“erase-remove”习惯用法。我不会在这里重复，因为你可以查一下。可以将计数计算为两个迭代器之间的差值

或者更好的是，在不删除它们的情况下计算因子，就像Niklas的评论一样。
从向量中删除会使迭代器无效并导致未定义的行为。同样的事情也可以通过使用
multiset（v.begin（），v.end（））
，或者通过一个简单的
for（int x:v）m[x++@NiklasB。值得一提的是，增强只用于C++中的工作11@dabadaba：是的，映射迭代器不支持随机ac