我有一个实现cbegin()和cend()功能的自定义容器类.然后我在foreach循环中使用它,但它似乎需要begin()和end()成员函数,即使我尝试使用const修饰符:
for (const auto val: container)
和这样:
for (auto const val: container)
和这样:
for (const auto const val: container)
是否有可能强迫foreach使用常数c函数？
我执行与代理迭代器/引用类型的容器类似,以std::vector<bool>和冲突到了以下问题,我着手进行例举std::vector<bool>(这个问题不是std::vector<bool>!):
#include <vector>
#include <type_traits>
int main() {
using namespace std;
vector<bool> vec = {true, false, true, false};
auto value = vec[2]; // expect: "vector<bool>::value_type"
const auto& reference = vec[2]; // expect: "vector<bool>::const_reference"
static_assert(is_same<decltype(value), vector<bool>::value_type>::value,
"fails: type is vector<bool>::reference!");
static_assert(is_same<decltype(reference),
vector<bool>::const_reference>::value,
"fails: type is const vector<bool>::reference&!");
/// Consequence:
auto other_value = value;
other_value = false;
assert(vec[2] == true && "fails: assignment modified the vector");
有没有办法实现代理类型,以便静态断言传递？
在实现这样的容器时,是否有关于如何处理此问题的指导原则？
也许通过使用转换运算符来auto/ auto&/ auto&& …
我不想压制警告.还有另一种处理此警告的方法吗？
"Iterator类型的表达式需要未经检查的转换以符合Iterator"
Iterator<String> it = schemaJSON.getJSONObject("body").keys();
我有以下ArrayList ...
ArrayList<ArrayList<Integer>> row1 = new ArrayList<ArrayList<Integer>>();
添加了以下arraylists ....
row1.add(cell1);
row1.add(cell2);
row1.add(cell3);
row1.add(cell4);
row1.add(totalStockCell);
我想遍历arraylist row1并打印内容.
循环中的循环会在这里工作吗？
例如
while(it.hasNext()) {
//loop on entire list of arraylists
while(it2.hasNext) {
//each cell print values in list
} }
假设我有一个非常大的整数列表,占用了大量的内存.如果列表的整数是偶数增量,那么我可以很容易地将列表表示为占用相对没有内存的迭代器.但是对于更复杂的模式,将此列表表示为迭代器将变得更加困难.
是否有一个Python包可以分析整数列表并返回"优化"迭代器？或者我可以研究的方法来实现这个目标？
我正在实现一个二维数组容器(比如boost::multi_array<T,2>,主要用于练习).为了使用双索引表示法(a[i][j]),我引入了一个代理类row_view(const_row_view但我不关心这里的constness),它保留了指向行的开头和结尾的指针.
我还希望能够分别遍历行和行内的元素:
matrix<double> m;
// fill m
for (row_view row : m) {
for (double& elem : row) {
// do something with elem
}
}
现在,matrix<T>::iterator类(用于遍历行)在row_view rv;内部保持私有以跟踪迭代器指向的行.当然,iterator也实现了dereferenciation功能:
operator*(),人们通常想要返回一个参考.相反,这里正确的做法似乎返回一个row_view值(即返回私有的副本row_view).这确保了当迭代器前进时,row_view静止指向前一行.(在某种程度上,row_view行为就像参考一样).因为operator->(),我不太确定.我看到两个选择:
返回指向row_view迭代器私有的指针:
row_view* operator->() const { return &rv; }
返回指向新的指针row_view(私有指针的副本).由于存储生命周期,必须在堆上分配.为了确保清理,我将其包装成unique_ptr:
std::unique_ptr<row_view> operator->() const {
return std::unique_ptr<row_view>(new row_view(rv));
}
显然,2更正确.如果迭代器 …
我理解(至少我认为我这样做)指针可以用作随机STL迭代器.
除非我将指针强制转换为迭代器,否则为什么以下代码无法编译？
vector<int> v{1, 2, 3};
v.erase(&v[0]);
我有一些类通常使用标准容器作为底层字段.例如,我有一个班级
template <typename T>
class Vec_3D
{
public:
/* ... */
std::array<T, 3> vec;
/* ... */
};
它只有一个变量vec,其余的只是我在处理矢量时需要的函数.我希望能够使用基于范围的for循环,例如
Vec_3D<double> vec;
for (double val : vec) {/*...*/}
这应该是很容易迭代的std::array<double, 3>.
如何在我的类中实现迭代器,而这又应该调用迭代器std::array<T, 3>？
我从这个问题开始,并尝试在我的类中定义迭代器
typedef std::iterator<std::random_access_iterator_tag, T, ptrdiff_t, T*, T&> iterator;
typedef std::iterator<std::random_access_iterator_tag, const T, ptrdiff_t, const T*, const T&> const_iterator;
inline iterator begin() noexcept { return vec.begin(); }
inline const_iterator cbegin() const noexcept { return vec.cbegin(); }
inline iterator end() noexcept { return …我想将a Vec分成等长的部分,然后map覆盖它们.我有一个呼叫产生的迭代器Vec的chunks()方法.这可能会让我的部分比其他部分小,这将是它产生的最后一个元素.
为了确保所有部分都具有相同的长度,我只想删除最后一个元素,然后调用map()左边的内容.
如何包装OutputIterator,例如back_inserter_iterator转换？考虑
std::vector<double> xx;
std::vector<double> yy;
std::vector<double> diff;
auto ba = std::back_inserter(diff);
std::set_difference(xx.begin(), xx.end(), yy.begin(), yy.end(), ba);
我想应用一个自由函数f(double)或g(std::vector<double>::iterator)在推回到diff矢量之前:
具体来说,我如何存储diff元素(或迭代器)的地址而不是元素本身.
std::vector<double&> diff;
auto baAdr = ??? std::back_inserter( ??? (diff));
std::set_difference(xx.begin(), xx.end(), yy.begin(), yy.end(), baAdr);
出于性能原因(真实数据很大),我不想构建一个临时向量std::transform.它也不适用于不可复制的可移动类型.
我可以用boost.