Neil Cerutti <le*******@emai l.com> wrote:
On 2005-12-01, Marcus Kwok <ri******@gehen nom.net> wrote: I am writing a program to read in a file, do some processing,
then write it out to a different file. I really like the idiom
I use for output:
// std::vector<std ::string> vec;
// std::ofstream out;
std::copy(vec.b egin(),
vec.end(),
std::ostream_it erator<std::str ing>(out, "\n"));
Is there a way to do the same thing for input that will read
whole lines? I tried the obvious thing:
// std::ifstream in;
std::copy(std:: istream_iterato r<std::string>( in),
std::istream_it erator<std::str ing>(),
std::back_inser ter(vec));
but it separates on whitespace so every word is a different
element in the vector. I would like it to do the same thing as
// std::string line;
while (std::getline(i n, line)) {
vec.push_back(l ine);
}
Implement a line-based input iterator. It should be a snap.
OK, my template technique is not too strong yet, so here is what I came
up with. Basically, I copied the implementation of istream_iterato r
from the STL that comes with VS .NET 2003 (I believe they still use
Dinkumware) but renamed some of the implementation items, and added a
specialization for std::string, so this may not be the simplest or most
elegant way. If anyone knows a simpler way to specialize
istream_iterato r for std::string then please enlighten me. Also, please
disregard some of the funky spacing, as I'm trying to get it to fit on
80 character lines for the NG post.
#include <iostream>
#include <string>
#include <fstream>
#include <algorithm>
#include <vector>
template <class T,
class Ch = char,
class Tr = std::char_trait s<Ch>,
class Dist = std::ptrdiff_t>
class my_istream_iter ator : public std::iterator<s td::input_itera tor_tag,
T,
Dist,
const T*,
const T&> {
public:
typedef my_istream_iter ator<T, Ch, Tr, Dist> my_t;
typedef Ch char_type;
typedef Tr traits_type;
typedef std::basic_istr eam<Ch, Tr> istream_type;
// construct singular iterator
my_istream_iter ator() : my_istream(0) { }
// construct with input stream
my_istream_iter ator(istream_ty pe& s) : my_istream(&s) { getval(); }
// return designated value
const T& operator*() const { return my_val; }
// return pointer to class object
const T* operator->() const { return &**this; }
// preincrement
my_istream_iter ator& operator++()
{
getval();
return *this;
}
// postincrement
my_istream_iter ator operator++(int)
{
my_t tmp = *this;
++*this;
return tmp;
}
// test for iterator equality
bool equal(const my_t& rhs) const { return my_istream == rhs.my_istream; }
protected:
// get a T value if possible
void getval()
{
if (my_istream != 0 && !(*my_istream >> my_val))
my_istream = 0;
}
istream_type* my_istream; // pointer to input stream
T my_val; // lookahead value (valid if my_istream is not null)
};
// specialization for std::string
template <>
void my_istream_iter ator<std::basic _string<char>, char,
std::char_trait s<char>, std::ptrdiff_t> ::getval()
{
if (my_istream != 0 && !(std::getline( *my_istream, my_val)))
my_istream = 0;
}
// my_istream_iter ator template operators
// test for my_istream_iter ator equality
template <class T, class Ch, class Tr, class Dist>
inline bool operator==(cons t my_istream_iter ator<T, Ch, Tr, Dist>& lhs,
const my_istream_iter ator<T, Ch, Tr, Dist>& rhs)
{
return lhs.equal(rhs);
}
template <class T, class Ch, class Tr, class Dist>
inline bool operator!=(cons t my_istream_iter ator<T, Ch, Tr, Dist>& lhs,
const my_istream_iter ator<T, Ch, Tr, Dist>& rhs)
{
return !(lhs == rhs);
}
int main(int argc, char* argv[])
{
std::ifstream in(argv[1]);
std::vector<std ::string> vec;
std::copy(my_is tream_iterator< std::string>(in ),
my_istream_iter ator<std::strin g>(),
std::back_inser ter(vec));
std::ofstream out(argv[2]);
std::copy(vec.b egin(),
vec.end(),
std::ostream_it erator<std::str ing>(out, "\n"));
return 0;
}
// vim: tabstop=4 shiftwidth=4
--
Marcus Kwok
