Преобразовать string в complex

string S="(1.00000 -2.12363e-09)";
complex cnum;

#include <iostream>
#include <string>
#include <sstream>
#include <complex>
// ...
  std::string s="(1.00000, -2.12363e-09)"; /* Запятая !*/
  std::stringstream ss;
  ss<<s;
 
  std::complex<double> num;
  if(ss>>num)
  {
    std::cout<<"ok! "<<num << std::endl;
  }
  else
  {
    std::cout<<"bad format!"<<std::endl;
  }

        string temp, x;  //  х содержит значение real
        double real, imag;
        complex<double> cx;
        string::const_iterator it=x.begin();
        if(*it=='(') {
          std::copy(x.begin()+1, x.end(), back_inserter(temp));
          real=atof(temp.c_str());
          temp.clear();
          ss>>x;  // получение img
          std::copy(x.begin(), x.end()-1, back_inserter(temp));
          imag=atof(temp.c_str());
          cx(real, imag);  //  [COLOR="Red"]вот это отвергается компилятором[/COLOR].
          temp.clear();
        } else {
          cx(atof(x.c_str()), 0.0);  //  [COLOR="red"]это тоже отвергается.[/COLOR]
        };

#include <boost/regex.hpp>
#include <boost/lexical_cast.hpp>
 
template<typename StringT,typename T>
bool tryStrToComplex(const StringT& str, std::complex<T>& num)
{
  using namespace boost;
 
  std::basic_stringstream<StringT::value_type> ss;
  ss<< "\\(\\s*?"
    << "([\\+\\-0-9\\.e]+)\\s+"
    << "([\\+\\-0-9\\.e]+)"
    << "\\s*?\\)";
  basic_regex<StringT::value_type> re(ss.str());
 
  match_results<StringT::const_iterator> m;
  try
  {
    if(regex_match(str,m,re))
    {
      T r = lexical_cast<T>(StringT(m[1]));
      T i = lexical_cast<T>(StringT(m[2]));
      num= std::complex<T>(r,i);
      return true;
    }
  }
  catch(const boost::exception&)
  { }
  return false;
}
//...
  std::string s="(1.00000 -2.12363e-09)";
  std::complex<double> num(1,1);
  if(tryStrToComplex(s,num))
  {
    std::cout<< num <<std::endl;
  }
  else
  {
    std::cout<<"bad cast!"<<std::endl;
  }

#include <complex>
#include <iostream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                 T_str;
typedef std::complex< double    >   T_complex;
/////////////////////////////////////////////////////////////////////////////////////////
T_complex   str_to_compl( T_str     s )
{
    T_complex   c;
    auto        ind     =   s.find('(');
 
    try
    {
        s   =   s.substr( ind + 1 );
        c.real  (   stod( s,                &ind    )   );
        c.imag  (   stod( s.substr( ind )           )   );
    }
    catch(...)
    {}
 
    return  c;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        std::cout   <<  "compl_str = ";
 
        T_str       s;
        getline( std::cin, s );
 
        std::cout   <<  str_to_compl(s)
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }//for
}

T_complex   str_to_compl( T_str     s )
{
    T_complex   c;
    auto        ind     =   s.find('(');
 
    try
    {
        s   =   s.substr( ind + 1 );
        c.real  (   stod( s,                &ind    )   );
    }
    catch(...)
    {
      cout<<"Out of range real!\n";
      return 1e+308;
    }
    try
    {
        c.imag  (   stod( s.substr( ind )           )   );
    }
    catch(...)
    {
      cout<<"Out of range imag!\n";
      return 1e+308;
    }
 
    return  c;
}