using namespace std;
class line : public string {};
istream& operator>>(istream& i, line& s)
{
  s.clear();
  getline(i, s);
  s.push_back('\n');
  return i;
}
struct funct : unary_function<const line&, line>
{
  line operator()(const line& l) const
  {
    return l;
  }
};
void foo()
{
  ifstream is("source.txt");
  istream_iterator<line> ii(is), eof;
  ofstream os("dest.txt");
  ostream_iterator<line> oo(os);
  transform(ii, eof, oo, funct());
}

istream& operator>>( istream& i, line& s )
{
	s.clear();
	getline( i, s );
	return i;
}

struct funct : unary_function< string, line >
...
string operator()( line l )

#include <string>
#include <iostream>
#include <fstream>
#include <iterator>
#include <algorithm>
#include <functional>
#include <sstream>
#include <set>
using namespace std;
const char* ar_tokens[] = { "#if", "#ifdef", "#ifndef", "#endif", "#error", "#elif", "#else", "#include" };
string to_string( int i )
{
	stringstream ss;
	ss << i;
	return ss.str();
}
class line : public string {};
istream& operator>>( istream& i, line& s )
{
	s.clear();
	getline( i, s );
	return i;
}
struct funct : unary_function< const line&, string >
{
	set< string > tokens_;
	int line_number_;
	string token_;
	bool is_preprocessor_token( const string& l )
	{
		string::size_type tok_begin = l.find_first_not_of( " \t" );
		if ( string::npos != tok_begin && l[tok_begin] == '#' )
		{
			string::size_type tok_end = l.find_first_of( " \t" );
			token_ = ( string::npos == tok_end ) ? 
				l.substr( tok_begin ) : l.substr( tok_begin, tok_end - tok_begin );
			if ( tokens_.find( token_ ) != tokens_.end() )
				return true;
		}
		return false;
	}
public:
	funct() : line_number_(0)
	{
		for( int i = 0; i < sizeof( ar_tokens ) / sizeof( char* ); ++i )
			tokens_.insert( ar_tokens[ i ] );
	}
	string operator()( const line& l )
	{
		++line_number_;
		return is_preprocessor_token( l ) ? to_string( line_number_ ) : l;
	}
};
int main()
{
	transform( istream_iterator<line>( ifstream("source.txt") ),
		istream_iterator<line>(),
		ostream_iterator<string>( ofstream("dest.txt"), "\n" ),
		funct() );
}

	funct f( someargs );
	transform( istream_iterator<line>( ifstream("source.txt") ),
		istream_iterator<line>(),
		ostream_iterator<string>( ofstream("dest.txt"), "\n" ),
		 f );
	// use f

void AFXAPI DDX_String( CDataExchange* pDX, int nIDC, std::string& value )
{
	HWND hWndCtrl = pDX->PrepareEditCtrl( nIDC );
	if ( pDX->m_bSaveAndValidate )
	{
		std::vector< char > v( ::GetWindowTextLength( hWndCtrl ) + 1, 0 );
		::GetWindowText( hWndCtrl, &v[0], v.size() );
		value = std::string( &v[0], v.size() - 1 );
	}
	else
		SetWindowText( hWndCtrl, value.c_str() );
}

CStdioFile iFile(bla bla);
CString str;
while (iFile.ReadString(str))
{
     bla bla
}

char temp=0;
csLineNumber=LineNumber(CString(ltoa(i,&temp,10)),2);

char *  ltoa ( long value, char * buffer, int radix );

Convert long integer value to string.
Converts a long integer value to a null-terminated string using the specified radix and stores the result in the given buffer. If radix is 10 and value is negative the string is preceded by the minus sign (-). With any other radix, value is always considered unsigned. buffer should be large enough to contain any possible value: (sizeof(long)*8+1) for radix=2.

template< class T >
std::string to_string( T t)
{
	stringstream ss;
	ss << t;
	return ss.str();
}

#include <boost/spirit/core.hpp>
#include <iostream>
#include <string>
#include <map>
using namespace std;
using namespace boost::spirit;
void set_object_name( char const* first, char const* last )
{
	cout << "Object name: " << string(first, last) << endl;
}
void set_object_attr_name( char const* first, char const* last )
{
	cout << "Object attribute name: " << string(first, last) << endl;
}
void set_object_attr_value( char const* first, char const* last )
{
	cout << "Object attribute value: " << string(first, last) << endl;
}
struct object_parser : public grammar< object_parser >
{
    template <typename ScannerT>
    struct definition
    {
        definition( object_parser const& /*self*/ )
        {
          expression = str_p( "#define" )
            >> word [ &set_object_name ]
            >> *attr
            ;
          attr = word [ &set_object_attr_name ]
            >> '=' 
            >> word [ &set_object_attr_value ]
            ;
          word = lexeme_d[ +(alnum_p | '_') ];
        }
        rule<ScannerT> expression, attr, attr_value, word;
        rule<ScannerT> const& start() const { return expression; }
    };
};
int main()
{
    object_parser parser;
    parse_info<> info = parse( "#define Name type=int xdm=3 ydm=2 model=KMO_2", parser, space_p );
    if ( ! info.full )
		cout << "Parsing failed at: " << info.stop << endl;
	
    info = parse( "#define Name2 type=uint", parser, space_p );
    if ( ! info.full )
		cout << "Parsing failed at: " << info.stop << endl;
}