标签: iterator

在迭代期间,不允许从集合中删除.我有一段代码正在工作,我认为不应该工作.它可能在将来失败,为什么它现在正在运作？

public class RemoveFromSet {

    static Set<Integer> set = new HashSet<>();
    public static void main(String[] args) {
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        while(set.size()>0) {
            int val = set.iterator().next();
            set.remove(val);
            System.out.println("removed val = "+val);
        }
    }

}

我正在为一个基于索引的类实现一个迭代器.有一个最大有效值; 我的问题是当客户端代码使迭代器超出我的end()值时该怎么做:

• 应该operator++()经常检查我没有结束？,或
• 应该operator*()经常检查我没有超过结束,而迭代器可以(无用)提前或移动到最后？

请解决一个非调试设置,在这个设置中我无法确定愚蠢的开发人员不会尝试在结束之前推进他们的指针.

以下生成错误:

int main() {

  mat_int mat1(5, vector<int>{1,2,3});
  mat_int mat2(5, vector<int>{4,5,6});

  for (auto it1 = mat1.begin(); it1 != mat1.end() ; ++it1) {
        for (auto it11 =  *it1.begin(); it11 != *it1.end(); it11++)
            cout << *it11;
        cout << '\n';
    }
}

编译器不接受内部循环迭代器; /home/asabbah/programming/C++/vectors1.cpp:16:28:错误:'class __gnu_cxx :: __ normal_iterator*,std :: vector >>>没有名为'begin'的成员

但是,如果我插入一个临时变量:

vector<int> temp = *it1;

然后:

for (auto it11 = temp.begin(); it11 != temp.end(); it11++);

一切顺利.

知道为什么会这样吗？

使用代码:

#include <iostream>
#include <map>
#include <string>

int main()
{
    std::map<int, std::map<std::string, int>> mm;

    std::map<std::string, int>::iterator iter = mm.find(1);
}

我收到以下错误:

Class 'std::_Rb_tree_iterator<std::pair<const int,
std::map<std::string, int>>>' is not compatible with class
'std::map<std::__cxx11::basic_string<char, std::char_traits<char>,
std::allocator<char>>, int>::iterator'

我没有编译代码.Clion提醒我,上面有一个错误.

我有一个创建建筑的小班.我想更多地了解国际热核实验堆.以下作品:

class Building(object):
    def __init__(self, floors):
        self._floors = [None] * floors

    def __setitem__(self, floor_number, data):
        self._floors[floor_number] = data

    def __getitem__(self, floor_number):
        return self._floors[floor_number]

    def __iter__(self):
        for floor_number in self._floors:
            yield self._floors[floor_number]


building1 = Building(9)  # Construct a building with 9 floors
building1[0] = 'Reception'
building1[1] = 'ABC Corp'
building1[2] = 'DEF Inc'
building1[3] = 'Apple'
building1[4] = 'Cisco'
building1[5] = 'Microsoft'
building1[6] = 'Dell'
building1[7] = 'EMC'
building1[8] = 'HPE'

'''
for floor in building1:
    print(building1[floor])
'''

print(building1[6]) …

迭代嵌套列表有很多问题,但是我想迭代嵌套列表并应用另一个列表.

这是我的场景:

def operation(a, b):
    return a + b

def magic_function(func, list, nested_list):
    """iterate over nested_list and apply the next element of list"""
    ...

magic_function(operation, [0, 0, 0, 10, 10, 10], [[1, 2, 3], [1, 2, 3]])

期望的输出:

[[1, 2, 3], [11, 12, 13]]

用numpy回答这个问题的冲动可能很强烈,但在实际情况中,这些是对象,而不是数字.

该标准itertools.chain.from_iterable在此处不起作用,因为它不保留列表的嵌套.

我正在尝试使用该retain(...)方法从向量中过滤掉值.目前,我的代码到目前为止

let results = get_data(); // Returns Result<Vec<MyData>, Box<Error>>

match results {
    Ok(mut my_data) => {

        // Make sure that `name` is not None
        myData.retain(|ref d| d.name.is_some());

        // Only keep data if 'name' is in this list
        let names = ["Alice", "Bob", "Claire"];
        my_data.retain(|ref d| names.contains(d.name.unwrap().as_str()));
    },
    Err(_) => {}
}

但是,这会产生错误

|
|     my_data.retain(|ref d| names.contains(d.name.unwrap().as_str()));
|                                           ^^^^^^^^^^^^^^^^^^^^^^^^ expected &str, found str
|
= note: expected type `&&str`
           found type `&str`

看起来编译器在这里告诉我两个不同的东西,但在这两种情况下它似乎都想要一个额外的参考.但是,当我尝试将相关行更改&names.contains(d.name.unwrap().as_str())为时,编译器会抛出以下错误.

|
|     my_data.retain(|ref …

我目前正在尝试复制a的一部分std::vector,从第一个值开始,直到"遇到"一系列值.我主要使用STL算法,尤其是std::find_if()(我知道还有其他方法可以实现第一句中所述的目标,但我主要是为了理解STL,所以使用它们会破坏基本目的).

作为一个例子,假设一个vector保持整数元素(originalvec在代码中)被复制,直到第一个6,然后直接连续7遇到.我知道如何比较6,然后我想在lambda的相同调用中进行比较,如果在6后面有一个7.我认为(不确定)为此,我需要得到一个迭代器6,然后使用std::advance()或者只使用operator++迭代器并将解除引用的值与7进行比较.但是,我不知道如何获得6 /当前比较的数字的迭代器？

#include <algorithm>
#include <vector>

using namespace std;

int main() {
    vector <int> originalvec = { 4, 8, 7, 6, 55, 2, 6, 7, 8 };
    vector <int> newvec;

    copy(originalvec.begin(),
        find_if(originalvec.begin(), originalvec.end(), [](int curnum) {
            return (curnum == 6);
        }),
        back_inserter(newvec));
    //why does newvec.begin() (instead of back_inserter(newvec)) not work?

    //current result:   newvec = {4, 8, 7}
    //wanted result :   newvec = {4, 8, 7, 6, 55, …

我有一个代码flush[*it % 4].push_back(*(it++) /= 4);,它意味着在递增it迭代器之前push_back新值(旧值/ 4),它是否正确或如何以最快的方式从迭代器获取值,除以4,存储它,在push_back中使用新值然后增加迭代器？

我有以下for循环,它遍历一个传递给引用传递给const的向量

void PrintVector(const vector<string>& myVector) {
    for(vector<string>::iterator itr = myVector.begin(); itr != myVector.end(); ++itr)
        someFunctionThatTakesAPassByReferenceToConstParameter(itr);
}

迭代器itr作为引用传递给函数someFunctionThatTakesAPassByReferenceToConstParameter().因此,可以保证此函数不会更改迭代器对象.即使这是有保证的,为什么代码不能编译？

编辑:我知道我可以使用const_iterator.但我想知道为什么这不编译.