这是我到目前为止所尝试的但没有成功:
std::string ReadPartial( std::ifstream& _file, int _size )
{
std::istreambuf_iterator<char> first( _file );
std::istreambuf_iterator<char> last( _file );
std::advance( last, _size );
return std::string( first, last );
}
我知道如何阅读整个文件.
std::string Read( std::ifstream& _file )
{
std::istreambuf_iterator<char> first( _file );
std::istreambuf_iterator<char> last();
return std::string( first, last );
}
但这不是我想要做的.我收到一个空字符串.如果我在调试器中查看第一个也是最后一个,即使在std :: advance之后它们指向同一个东西.
我想弄清楚这里有几件事:
如何为下面的类实现迭代器？
#include <iostream>
#include <vector>
using namespace std;
template <typename T>
class Node {
public:
Node(int i=0):val(i) {}
Node*& operator++(int i=0) {return next;};
T val;
Node *next;
};
//================================================
int main() {
Node<int> *head, *tmp1, *tmp2;
tmp1 = new Node<int>(0);
head = tmp1;
for (int i=1; i<10; ++i) {
tmp2 = new Node<int>(i);
tmp1->next = tmp2;
tmp1 = tmp2;
}
while (head != NULL) {
cout << head->val << " '";
head = head->operator++(0); //How do I make …您如何从生成器外部访问Python生成器中定义的局部变量？
我有一个案例,我的生成器操纵一个本地状态,对于单元测试我想检查这个状态,以确保它包含正确的值.
我无法将状态存储到实例变量(例如self.state = blah),因为我可能正在从同一个类实例创建多个生成器,这意味着生成器可能会覆盖彼此的状态.我也无法在yield表达式中返回状态,因为状态名称可能因个别生成器实例而改变或变化.
例如,我想做这样的事情(虽然这段代码不起作用)
from random import random
class MyIter(object):
def __iter__(self):
context = {}
for i in xrange(10):
context[random()] = random()
yield i
obj = MyIter()
i1 = iter(obj)
i2 = iter(obj)
while 1:
try:
i1.next()
i2.next()
print i1.context
print i2.context
except StopIteration:
break
无论如何通过检查Python的执行堆栈来访问局部变量？
我正在使用以下代码为图像添加一些噪声(直接来自OpenCV参考,第449页 - 解释cv::Mat::begin):
void
simulate_noise(Mat const &in, double stddev, Mat &out)
{
cv::Size s = in.size();
vector<double> noise = generate_noise(s.width*s.height, stddev);
typedef cv::Vec<unsigned char, 3> V4;
cv::MatConstIterator_<V4> in_itr = in.begin<V4>();
cv::MatConstIterator_<V4> in_end = in.end<V4>();
cv::MatIterator_<V4> out_itr = out.begin<V4>();
cv::MatIterator_<V4> out_end = out.end<V4>();
for (; in_itr != in_end && out_itr != out_end; ++in_itr, ++out_itr)
{
int noise_index = my_rand(noise.size());
for (int j = 0; j < 3; ++j)
(*out_itr)[j] = (*in_itr)[j] + noise[noise_index];
}
}
没有什么过于复杂:
in并out …我只是想知道,因为你std::sort无论如何只能传递随机访问迭代器,为什么不通过首先为随机访问迭代器定义它来强制执行该限制？
#include <iterator>
#include <type_traits>
template <typename ForwardIterator>
typename std::enable_if<
std::is_same<
typename std::iterator_traits<ForwardIterator>::iterator_category,
std::random_access_iterator_tag>::value,
void>
::type sort(ForwardIterator begin, ForwardIterator end)
{
// ...
}
我发现单行错误消息比实现中远远类型错误导致的错误消息的页面和页面更容易阅读.
您可以对其他算法执行相同的操作.标准的C++核心语言一直都足以表达这项任务,对吧？那么,为什么没有这样做的任何特殊原因？
我试图使用迭代器模式迭代和打印,但我得到一个erorr
这是错误:
error C2679: binary '<<' : no operator found which takes a right-hand operand of type 'std::string' (or there is no acceptable conversion)
1> could be 'std::basic_ostream<_Elem,_Traits> &std::operator <<<char,std::char_traits<char>> (std::basic_ostream<_Elem,_Traits> &,const char *)'
这里是错误源自std :: cout << menuItem-> getName();
#ifndef _ROBOT1_
#define _ROBOT1_
namespace guitars {
namespace Composite {
namespace InventoryParts {
using namespace std;
#include <iostream>
//#include <string>
class Robot1 {
Menu* _partsMenu;
private:
public: Robot1( Menu* parts ) : _partsMenu( parts ) { assert( parts );
} …我正在尝试实现一个允许用户输入某种类型的开始和结束迭代器的函数,然后所有函数都对数据执行一些操作.然而,该功能必须足够通用的,应该对很多类型的迭代工作(例如std::vector::iterator,std::string::iterator,std::iterator等).唯一的限制是迭代器必须至少是forward_iterator_tag功能.
我的函数原型看起来像这样:
template <class key_type, class data_type> std::shared_ptr<data_type>
remove(std::iterator<std::forward_iterator_tag, key_type> key_start,
std::iterator<std::forward_iterator_tag, key_type> key_end);
但是,这限制了我特别使用forward_iterator_tag迭代器,因此尝试调用这样的函数:
remove<char, char>(std::iterator<std::random_access_iterator_tag, char>(), std::iterator<std::random_access_iterator_tag, char());
将失败,因为编译器无法将a转换std::iterator<std::random_access_iterator_tag,...>为a std::iterator<std::forward_access_iterator_tag,...>.此外,此方法不适用于字符串迭代器,矢量迭代器或其他stl迭代器.
有人知道stl如何实现容器/字符串以接受彼此的迭代器吗？例如,这正确编译:
std::string a = "hello";
std::vector<char> v(a.begin(), a.end());
我正在编写一个实用程序函数,它将获取元素的向量(可以是string,int,double,char)并连接成一个字符串并返回它.它看起来像这样:
template<typename T>
std::string convert2Str(std::vector<T> const& vec)
{
std::ostringstream sStream;
for (size_t k=0; k<vec.size(); ++k) {
sStream << vec[k] << " ";
}
return sStream.str();
}
我想使这个功能更通用:
vector<T>.我std::vector<T>::const_iterator it = vec.begin()在循环之前尝试了这个
并且编译器给了我一个错误:: error:;在它之前预期当我改变上面的定义时std::vector<std::string>::const_iterator it = vec.begin(),错误就消失了.所以,看起来我没有遵循正确的语法,请让我知道它是什么vector,list,queue,deque,等),我想要做上述同样的事情.我尝试在stackoverflow中搜索这个并没有找到满意的答案.我正在使用第三方API(确切地说是CryptEncrypt),它将C数组作为输入输出参数.从逻辑上讲,API归结为以下功能:
void add1(int *inout, size_t length)
{
for(size_t i = 0; i < length; i++)
{
inout[i] += 1;
}
}
我试图避免使用原始数组,所以我的问题是我可以使用std :: vector作为上面API的输入吗？类似于以下内容:
#include <vector>
int main()
{
std::vector<int> v(10); // vector with 10 zeros
add1(&v[0], v.size()); // vector with 10 ones?
}
我可以使用向量的"连续存储"保证向其写入数据吗？我倾向于认为这是可以的(它适用于我的编译器),但如果比我更有知识的人能够确认这样的用法是否违反C++标准保证,我会感觉好多了.:)
提前致谢!
在Python中获取迭代器的最后N个元素的最佳方法是什么？以下是理论行动中的一个例子:
>>> list(all_but_the_last_n(range(10), 0))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(all_but_the_last_n(range(10), 2))
[0, 1, 2, 3, 4, 5, 6, 7]