C / C++ / MFC

Stephen Hewitt wrote:

The third argument should be osi, not isi: isi is an input iterator.

// begin: file "data.txt" content:
ABC DEF
// end: file "data.txt"

// The code:
using namespace std;
fstream file("data.txt", ios::in); // I only want to modify content in the temporary buffer.
                                   // I do not want it to write back to physical file "data.txt".
file >> noskipws;
istream_iterator<char> isi(file);
istream_iterator<char> isi_end;
ostream_iterator<char> osi(file);
transform(isi, isi_end, osi, ::tolower);
file.clear(); // clear eof.
file.seekg(0, file.beg); // rewind.
string s;
while(!file.eof()) {
  getline(file, s);
  cout << s << end;
}

ABC DEF

// VanillaConsole.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
#include <iterator>
#include <algorithm>
 
int main(int argc, char* argv[])
{
	using namespace std;
 
	// Open the input file.
	ifstream ifs("C:\\Data.txt");
	if (!ifs)
	{
		cerr << "Failed to open data file!" << endl;
		return 1;
	}
 
	// Get iterators for the file.
	istream_iterator<char> isi(ifs);
	istream_iterator<char> isi_end;
 
	// The string to put the contents of the file in (but in lower case).
	string s;
 
	// Copy the file's contents to the string but in lower case.
	transform(isi, isi_end, back_inserter(s), ::tolower);
 
	// Output the results.
	cout << s << endl;
 
	return 0;
}

Stephen Hewitt wrote:

transform(isi, isi_end, back_inserter(s), ::tolower);

// VanillaConsole.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <iostream>
#include <string>
#include <map>
#include <algorithm>
#include <functional>
#include <boost/bind.hpp>
using namespace std;
 
class MyType
{
public:
	MyType(const string &name) : m_name(name) {}
 
	void Method()
	{
		cout << m_name << endl;
	}
 
private:
	string m_name;
};
 
typedef std::map<int, MyType> Map_t;
 
int main(int argc, char* argv[])
{
	Map_t m;
 
	// Populate the map with some entries.
	m.insert(Map_t::value_type(1, MyType("One")));
	m.insert(Map_t::value_type(2, MyType("Two")));
	m.insert(Map_t::value_type(3, MyType("Three")));
	m.insert(Map_t::value_type(4, MyType("Four")));
	m.insert(Map_t::value_type(5, MyType("Five")));
 
	// Here's the tricky bit...
	for_each(m.begin(), m.end(), boost::bind(&MyType::Method, boost::bind(&Map_t::value_type::second, _1)));
 
	return 0;
}

Josh Gray wrote:

Someone here pointed out to me that this is not an efficient way of doing this as the bind is called once for each item in the sellection.

gluballs wrote:

That way I can avoid the current problem of not having a contiguous block of memory large enough to hold my object.

gluballs wrote:

For example, can I keep appending to a map object if it's memory exceeds the largest contiguous memory block on my machine?

gluballs wrote:

40M words

Josh Gray wrote:

Yep because each node is allocated individually.

Josh Gray wrote:

...thats a lot of items. Have you looked into memory mapped files?

Josh Gray wrote:

Yep because each node is allocated individually.

gluballs wrote:

2) Another problem is the matter of efficiency.

act_x wrote:

I am adding the code to display some status in the List Control