int col=boost::lexical_cast<int>(str);

#if defined(BOOST_NO_STRINGSTREAM)
std::strstream stream;
#elif defined(BOOST_NO_STD_LOCALE)
std::stringstream stream;
#else
std::basic_stringstream<char_type> stream;
#endif

S>#if defined(BOOST_NO_STRINGSTREAM)
S>std::strstream stream;
S>#elif defined(BOOST_NO_STD_LOCALE)
S>std::stringstream stream;
S>#else
S>std::basic_stringstream<char_type> stream;
S>#endif
S>

  /** Integer to string converter.**/
  class itoa 
  {
    char buffer[38];
  public:
    itoa(int n, int radix = 10) { _itoa(n,buffer,radix); }
    operator const char*() { return buffer; }
  };

std::string s = itoa(28);

S>int col=boost::lexical_cast<int>(str);
S>

S>Или может есть что-то побыстрее и не менее красивое. atoi не предлагать

#include <string>
#include "boost/spirit/core/scanner/scanner.hpp"
#include "boost/spirit/core/primitives/numerics.hpp"

template <class IteratorT>
IteratorT string2int(IteratorT first, IteratorT last, int& val)
{
    namespace bs = boost::spirit;

    typedef bs::scanner<IteratorT, bs::scanner_policies<> >             scanner_type;
    typedef bs::int_parser<int>                                         parser_type; 
    typedef typename bs::parser_result<parser_type, scanner_type>::type result_type;
    
    scanner_type scan(first, last);

    if (result_type result = bs::int_p.parse(scan))
        val = result.value();

    return scan.first;
}

int main()
{
    std::string str= "123vs";
    int n = 0;
    string2int(str.begin(), str.end(), n);
    return 0;
}

KP>#include <string>
KP>#include "boost/spirit/core/scanner/scanner.hpp"
KP>#include "boost/spirit/core/primitives/numerics.hpp"

KP>template <class IteratorT>
KP>IteratorT string2int(IteratorT first, IteratorT last, int& val)
KP>{
KP>    namespace bs = boost::spirit;

KP>    typedef bs::scanner<IteratorT, bs::scanner_policies<> >             scanner_type;
KP>    typedef bs::int_parser<int>                                         parser_type; 
KP>    typedef typename bs::parser_result<parser_type, scanner_type>::type result_type;
    
KP>    scanner_type scan(first, last);

KP>    if (result_type result = bs::int_p.parse(scan))
KP>        val = result.value();

KP>    return scan.first;
KP>}

KP>int main()
KP>{
KP>    std::string str= "123vs";
KP>    int n = 0;
KP>    string2int(str.begin(), str.end(), n);
KP>    return 0;
KP>}
KP>

KP>Когда то кстати я делал замеры скорости функций парсинга строки в double и что интересно boost::spirit::real_p был быстрее библиотечной strtod.

for(int v,poz;?;poz++)
 v=v*10+str[poz];

#include <iostream>
#include <utility>
#include <string>
#include <vector>
#include <fstream>
#include <algorithm>
#include <set>
#include <sstream> 
int main (int, char**)
{ 
  
  FILE *fi=fopen("123.tmp","wt");
  enum {BN=500000};
  int j; char bb[BN+5];
  for(j=BN;j--;)
    fputc('0',fi);
  fputs("--\n",fi);
  fclose(fi);

  fi=fopen("123.tmp","rt");
  fgets(bb,BN+3,fi);
  j=strlen(bb);
  fclose(fi);

  std::ifstream in("123.tmp");
  std::string is;
  getline(in,is); // уходит в себя надолго
  j=is.size();

}

struct itoa_result
{
    char elems[12]; // assume 32-bit int
};
itoa_result itoa(int n);

A typical call of this function would look like this:

s += itoa(n).elems;

struct S12{ char s[12];};
char * itoa_result(int v,char *r=S12().s)
{ ....................
  return r;
}

template<typename ToType,typename FromType>
inline void do_lexical_cast(ToType& to,const FromType& from)
{
  to=boost::lexical_cast<ToType>(from);
}

P>>struct S12{ char s[12];};
P>>char * itoa_result(int v,char *r=S12().s)
P>>{ ....................
P>>  return r;
P>>}
P>>

#include <stdio.h>
template<int N> struct ShortLine {char str[N];};

char *val2str(int v,char *f="%d",char *b=ShortLine<20>().str)
   {  sprintf(b,f,v);
      return b;
   }

void main(int, char ** )
{  char buf[64];
   printf(" %s %s %s\n",val2str(1),val2str(2),val2str(3,"pe4ataem %d",buf));
}

int& ir(int  &ii=(int &)(int const &)int(0))
{ ii=9;
  return ii;
}

struct ErrorInfo
{  int errnum;
   char *msg;
   ErrorInfo():errnum(0),msg(0){};
};

ErrorInfo& do_WITH_HANDLE(int HANDLE,ErrorInfo &ei=(ErrorInfo&)(ErrorInfo const&)ErrorInfo())
{ return ei;
}
#include <iostream>
void xz()
{ ir();
  if(do_WITH_HANDLE(0).errnum)
    std::cout<<"чет не так\n";
}