标签: const-iterator

autoC++ 11 的类型很方便,所以现在也想要一个const_auto类型.例如,假设std::list<T> a;,如果

auto p = a.begin();

有类型std::list<T>::iterator,然后有人希望

const_auto p = a.begin();

有类型std::list<T>::const_iterator.不幸的是,C++ 11似乎没有听说过const_auto.因此,如何才能以良好的风格达到理想的效果呢？

(有关信息,请在此处提出并回答相关问题.)

我正在将一大块代码从gcc移植到Visual Studio 2013.以下代码示例在gcc 4.4上工作正常(!),但在VS2013上编译begin()并end()失败:

错误C2440:'':无法从'unsigned char*'转换为'std :: _ Vector_const_iterator >>'

class foo {
    unsigned char* value;
    int length;

    std::vector<unsigned char>::const_iterator begin();
    std::vector<unsigned char>::const_iterator end();
};

std::vector<unsigned char>::const_iterator foo::begin() {
    return std::vector<unsigned char>::const_iterator(value);
}

std::vector<unsigned char>::const_iterator foo::end() {
    return std::vector<unsigned char>::const_iterator(value + length);
}

鉴于我不想重写整个事物,是否有可行的方法来创建这些const_iterators？

我写了下面的代码片段,但它似乎没有工作.

int main(){
    int VCount, v1, v2;
    pair<float, pair<int,int> > edge;
    vector< pair<float, pair<int,int> > > edges;
    float w;
    cin >> VCount;
    while( cin >> v1 ){
        cin >> v2 >> w;
        edge.first = w;
        edge.second.first = v1;
        edge.second.second = v2;
        edges.push_back(edge);
    }
    sort(edges.begin(), edges.end());
    for ( vector < pair<float,pair<int,int>> >::const_iterator it = edges.begin() ; itt != edges.end; it++){
        cout >> it.first;
    }
    return 0;
}

它在包含for循环的行中抛出错误.错误是:

error: no match for ‘operator<’ in ‘it < edges.std::vector<_Tp, _Alloc>::end [with _Tp = …

我想观察cbegin和begin之间的区别。

但是当我使用cbegin时，我得到的结果与开始相同。根据定义，cbegin将返回const itertaor，我们无法使用cbegin返回的const iterator修改元素。但是，我仍然能够擦除特定位置的元素。

    for (auto i = g1.cbegin(); i != g1.cend(); ++i){             
            cout << *i << " ";
    }
    //below code erases element at const pointer
    g1.erase(i);

我有以下代码片段（您可以在此处运行：http://coliru.stacked-crooked.com/a/2f62134b5c125051）

#include <iostream>
#include <set>
#include <map>

int main() 
{
    std::set<std::pair<const int, const int>> const mySet{{0,0}}; // value_type = std::pair<const int, const int>
    for (std::set<std::pair<const int, const int>>::iterator it  = mySet.cbegin(); it != mySet.cend(); ++it)
    {
        std::cout<<"set it = " << it->first << " " << it->second << std::endl;
    }

    std::map<const int, const int> const myMap{{0,0}}; // value_type = std::pair<const int, const int>
    for (std::map<const int, const int>::iterator it  = myMap.cbegin(); it != myMap.cend(); ++it)
    {
        std::cout<<"map it …

我正在尝试使用我的项目符号列表。每当我运行更新项目符号代码时，它都会出现以下错误：

错误 1 ​​错误 C2662：“Bullet::detectCollision”：无法将“this”指针从“const Bullet”转换为“Bullet &”

我的列表：

std::list<Bullet> bullet_list;

我的更新代码：

std::list<Bullet>::const_iterator cIter;
    for ( cIter = bullet_list.begin( ); cIter != bullet_list.end( ); cIter++ )
    {
        if((*cIter).detectCollision(monster.position,monster.getHeight(),monster.getWidth()))
        {
//Do stuff here
        }
        if ((*cIter).detectCollision(boss.getPosition(),boss.getHeight(),boss.getWidth()))
        {
//Do stuff here
        }
    }

我的检测碰撞代码：

bool Bullet::detectCollision(Vector objTwo,int heightT,int widthT)
{
if(position.getVectorX() >= objTwo.getVectorX() - (widthT/2) && position.getVectorX() <= objTwo.getVectorX() + (widthT/2)
    && position.getVectorY() >= objTwo.getVectorY() - (widthT/2)&& position.getVectorY() <= objTwo.getVectorY() + (heightT/2) && alive)
{
    return false;
}
return true;
}

这是我的代码:

#include <set>
#include <iostream>
using namespace std;

int main(){
    set<int> st;
    st.insert(1);
    int x = st.find(1) - st.begin();

    return 0;
}

我到了error: no match for 'operator-' in 'st.std::set<_Key, _Compare, _Alloc>::find [with _Key = int, _Compare = std::less<int>, _Alloc = std::allocator<int>](((const int&)((const int*)(&1)))) - st.std::set<_Key, _Compare, _Alloc>::begin [with _Key = int, _Compare = std::less<int>, _Alloc = std::allocator<int>]()'.

我无法弄清楚迭代器差异是如何突然停止工作的!我在这里错过了什么吗？

如果我有一个包含另一个向量的迭代器的向量.

例如 :

vector<vector<int>::iterator> vec;

在const refrence中传递这个向量会发生什么？

例如:

void fun(const vector<vector<int>::iterator> &vec);

函数内部的vec元素是有趣的const_iterator还是迭代器？可以修改它们吗？

提前致谢!

研究

我找到了这个老答案.我想知道解决方案是否仍然有效,或者是否有更新,更有效的方法.

背景

让我们假设我有一个像下面这样的迭代器(细节并不重要,只是它很大):

    class inorder_iterator : public std::iterator<std::forward_iterator_tag, token>
    {
        friend syntax_tree;

        node* current_node;
        std::stack<node*> prev_nodes;
        //std::stack<node*> visited_nodes;
        std::map<node*, bool> visited;
    public:
        inorder_iterator();

        inorder_iterator& operator++();
        inorder_iterator operator++(int);

        token& operator*();
        const token& operator*() const;

        token* operator->();
        const token* operator->() const;

        friend bool operator==(const inorder_iterator lhs, const inorder_iterator rhs);
        friend bool operator!=(const inorder_iterator lhs, const inorder_iterator rhs);

    private:
        inorder_iterator(node* current);
        node* find_leftmost_node(node* from);
    };

问题

成员函数声明的实现具有合理的大小,但我想重用当前的迭代器来减少代码重复.

理念

想到的第一个想法就是在node类型上进行模板化,所以我可以通过const node使它成为const迭代器,但它听起来很腥

template <typename Node>
//replace every occurrence …

我试图比较a const iterator和a,non-const iterator但不确定它是否正常,所以我查了一下.由于隐式转换为non-const iterator,我发现它没问题const iterator.但是,我想知道您是否应该不要比较这些迭代器,以避免这种转换.例如,

begin_iterator = buf.begin();  end_iterator = buf.cend();
for (; begin_iterator != end_iterator; ++begin_iterator) { ... }

通常,我会认为这是正常的,因为const意味着只读,这很好.但是,我不确定(不必要的)转换.