我正在试图弄清楚对forward_iterators reference类型的要求是什么.在明显的情况下,你将拥有value_type = T;和reference = T&;.我看到了读取前向迭代器需求的cppreference页面
Expression Return Equivalent expression
*i++ reference value_type& temp=*i; ++i; return temp;
std::vector<bool> 表明"等效表达式"并不总是有效,因为它返回一个代理对象:
std::vector<bool> v(10);
auto i = v.begin();
std::vector<bool>::iterator::value_type& temp = *i; // error
// can't bind bool& to std::_Bit_reference
我看到的标准中没有提到等效表达式.代理对象允许分配,这可能是一致性的关键.
除了试图确定要求之外,我的具体问题涉及知道是否具有value_type== reference既不是引用也不支持赋值,也适用于标准库.
将一些Container<int>带有iterator标记为forward_iterator_tag和reference == int有效吗？
假设链接列表以这种方式定义:
template <typename Object>
struct Node{
Object data;
Node *prev;
Node *next;
Node(const Object & d = Object(), Node *p = NULL, Node *n = NULL)
: data(d), prev(p),next(n){}
};
template <typename Object>
class List
{
public:
iterator begin(){return iterator(head->next);}
iterator end(){return iterator(tail);}
....
private:
Node *head=nullptr;
Node *tail=nullptr;
...
迭代器:
class iterator
{
public:
iterator():current(NULL){}
Object & operator*(){return retrieve();}
iterator & operator++()
{
current = current->next;
return *this;
}
....
private:
Node *current;
...
此代码中存在问题.
for(iterator<Object> itr = list.begin(); …例如,假设我有一个const_iterator:
QHash<const QString, QPair<const Node, double> >::const_iterator citer = adjNodeHash.begin();
然后我可以将citer存储在一个数据结构(包含许多迭代器)中并在以后重新使用它,它仍然指的是我下次使用它时离开的那个地方吗？(假设我相应地更新它/在我递增它时使用它的引用)
我问这个是因为我使用了这种方法但是我得到了一些未定义的行为,我想知道这是否是罪魁祸首.
任何帮助将非常感激.
有人可以向我解释C++中const iterator引用和non-const iterator引用之间的区别吗？为什么我不能non-const iterator在print函数中使用引用？
以下代码无法编译.
#include <deque>
#include <iostream>
using namespace std;
template<typename T> ostream & print(T & start, T & end) {
for (; start != end; ++start) {
cout << *start << " ";
}
return cout;
}
int main() {
int tab[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
deque<int> d1(tab, tab + 10);
deque<int> d2;
deque<int>::iterator it;
for (it = d1.begin(); it != d1.end(); …我正在学习C++,我正在阅读有关STL容器,迭代器以及可以对它们执行的操作的内容.我知道每个容器类型(或者更好,每个类型都是实例的相应模板)定义了一个类似于指针类型的companio类型,它被称为迭代器.我理解的是,一旦你得到一个容器的迭代器,执行像添加元素之类的操作可能会使该迭代器失效,所以我尝试用一个例子来测试这个语句:
#include <vector>
#include <iostream>
using namespace std;
int main()
{
vector<int> ivec={1,2,3,4,5,6,7,8,9,0};
auto beg=ivec.begin();
auto mid=ivec.begin()+ivec.size()/2;
while (beg != mid) {
if (*beg==2)
ivec.insert(beg,0);
++beg;
}
for (auto i:ivec)
cout<<i<<" ";
}
在这里,我只是构建一个int向量,大括号初始化它,并执行基于条件的操作,在容器的前半部分插入一个元素.该代码是有缺陷的,我认为,因为我初始化2个迭代器对象beg
和end,然后我在while语句作为条件使用它们.但是,如果代码应该更改容器的内容(并且确实如此)迭代器会发生什么？代码似乎运行得很好,它在ivec [1]位置添加0并打印结果.
我认为beg迭代器会指向新添加的元素,mid迭代器会指向前面指向mid的元素(就像迭代器指向相同的内存位置而底层数组"滑动")在..除非它被重新分配,是)
有人能解释我这种行为吗？
在下面的代码我无法识别--it和之间的区别it-1.同样是words.end()值超出设定范围？
#include <iostream>
#include<set>
using namespace std;
int main()
{
set<string> words;
words.insert("test");
words.insert("crack");
words.insert("zluffy");
set<string>::iterator it=words.end();
cout<<*(--it)<<endl;//just works fine
cout<<*(it-1)<<endl;//Error
return 0;
}
我有一个由两个迭代器(start和end)定义的子字符串.我需要检查这个子字符串是否存在于另一个字符串中.
是否有标准库算法或字符串成员我可以使用或适应这样做而不创建一个全新的字符串对象(std::string(start, end))只是为了这个目的？
例如
struct Substring
{
std::string::const_iterator start, end;
};
auto found = std::contains(whole.begin(), whole.end(), substring.start, substring.end); // ???
所以我正在尝试对列表进行排序.在每个子列表内部,元素是包含运行时的类.这是我用来排序列表的整数变量.
但是,如果最小的运行时位于列表的末尾,则列表不会100%排序.我在终端输出下面附有一张图像用于可视化.
这是代码:
void sort( list<list<MetaData> > &omegaList )
{
// variables
list<list<MetaData> >::iterator cursor = omegaList.begin();
list<list<MetaData> >::iterator ptr = omegaList.begin();
list<list<MetaData> >::iterator end = omegaList.end();
// start the bubble sort...
for(; cursor != end; cursor++)
{
// iterate through the list
for(; ptr != end; ptr++)
{
// compare runtimes of different lists
if( ptr->front().getProcessRunTime() < cursor->front().getProcessRunTime() )
{
// swap locations of lists in omegaList
swap( *ptr, *cursor );
// reset
cursor = ptr = omegaList.begin();
} …我遇到一些Rust代码有问题.我有一个相当简单的函数,但它在代码中抛出错误似乎是无关的:
use std::env::Args;
fn without_xxx(args: Args) -> Vec<String>{
let mut out: Vec<String> = vec![];
let mut xxx = false;
for arg in args{
match &arg{
"-" => xxx=true, //this line
_ => out.push(arg.to_string())
}
}
return out;
}
如果您注释掉标记的行,则不会显示错误.但是,通过这条简单的线条,它揭示了这一套神秘的错误:
<anon>:7:9: 12:10 error: the trait `core::marker::Sized` is not implemented for the type `str` [E0277]
<anon>: 7 for arg in args{
<anon>: 8 match &arg{
<anon>: 9 "-" => xxx=true,
<anon>:10 _ => out.push(arg.to_string())
<anon>:11 }
<anon>:12 }
<anon>:7:9: 12:10 help: see …我使用以下std :: move语法:
std::move(values.begin(), values.end(), dest);
dest是一个正向输出迭代器,目标容器至少有values.size()后面的项目dest
问题是,我在循环中多次调用它,但dest似乎是通过复制传递,因此dest指向的项目每次都被覆盖,而不是被追加.
我知道我dest += values.size();每次都可以使用,但那是为了更好的知识......
谢谢