C++ parsse int van string

mogelijk Duplicaat:
Hoe een tekenreeks te parseren naar een int in C++?

Ik heb wat onderzoek gedaan en sommige mensen zeggen om Atio te gebruiken en anderen zeggen dat het slecht is, en ik kan het toch niet aan het werk krijgen.

Dus ik wil gewoon uit vragen, wat is de juiste manier om een ​​tekenreeks om te zetten naar een int.

string s = "10";
int i = s....?

Bedankt!

Antwoord 1, Autoriteit 100%

• In C++ 11, gebruik std::stoials:

  std::string s = "10";
   int i = std::stoi(s);
  

  Houd er rekening mee dat std::stoiUITSCHREVEN VAN TYPE std::invalid_argumentAls de conversie niet kan worden uitgevoerd, of std::out_of_rangeAls de conversie resulteert in overloop (dwz wanneer de stringwaarde te groot is voor inttype). U kunt std::stolof std:stollhoewel in het geval intlijkt te klein voor de invoerreeks.

• In C++ 03/98 kan een van de volgende hand worden gebruikt:

  std::string s = "10";
   int i;
   //approach one
   std::istringstream(s) >> i; //i is 10 after this
   //approach two
   sscanf(s.c_str(), "%d", &i); //i is 10 after this
  

Merk op dat de bovenstaande twee benaderingen zouden mislukken voor invoer s = "10jh". Ze zullen 10 retourneren in plaats van een fout te melden. Dus de veilige en robuuste benadering is om je eigen functie te schrijven die de invoerreeks ontleden, en elk teken te verifiëren om te controleren of het een cijfer is of niet, en dan dienovereenkomstig te werken. Hier is een robuuste implementatie (hoewel niet getest):

int to_int(char const *s)
{
     if ( s == NULL || *s == '\0' )
        throw std::invalid_argument("null or empty string argument");
     bool negate = (s[0] == '-');
     if ( *s == '+' || *s == '-' ) 
         ++s;
     if ( *s == '\0')
        throw std::invalid_argument("sign character only.");
     int result = 0;
     while(*s)
     {
          if ( *s < '0' || *s > '9' )
            throw std::invalid_argument("invalid input string");
          result = result * 10  - (*s - '0');  //assume negative number
          ++s;
     }
     return negate ? result : -result; //-result is positive!
} 

Deze oplossing is een enigszins aangepaste versie van mijn andere oplossing.

Antwoord 2, autoriteit 13%

Je kunt boost::lexical_castgebruiken:

#include <iostream>
#include <boost/lexical_cast.hpp>
int main( int argc, char* argv[] ){
std::string s1 = "10";
std::string s2 = "abc";
int i;
   try   {
      i = boost::lexical_cast<int>( s1 );
   }
   catch( boost::bad_lexical_cast & e ){
      std::cout << "Exception caught : " << e.what() << std::endl;
   }
   try   {
      i = boost::lexical_cast<int>( s2 );
   }
   catch( boost::bad_lexical_cast & e ){
      std::cout << "Exception caught : " << e.what() << std::endl;
   }
   return 0;
}

Antwoord 3, autoriteit 8%

Er is geen “juiste manier”. Als u een universele (maar suboptimale) oplossing wilt, kunt u een boost::lexical castgebruiken.

Een veelgebruikte oplossing voor C++ is om std::ostreamen << operator. Je kunt een stringstreamen stringstream::str()methode gebruiken voor conversie naar string.

Als je echt een snel mechanisme nodig hebt (denk aan de 20/80-regel), kun je zoeken naar een “toegewijde” oplossing zoals C++ String Toolkit-bibliotheek

Met vriendelijke groet,
Marcin

Antwoord 4, autoriteit 7%

Je kunt istringstreamgebruiken.

string s = "10";
// create an input stream with your string.
istringstream is(str);
int i;
// use is like an input stream
is >> i;

Antwoord 5, autoriteit 5%

Enkele handige snelle functies (als je Boost niet gebruikt):

template<typename T>
std::string ToString(const T& v)
{
    std::ostringstream ss;
    ss << v;
    return ss.str();
}
template<typename T>
T FromString(const std::string& str)
{
    std::istringstream ss(str);
    T ret;
    ss >> ret;
    return ret;
}

Voorbeeld:

int i = FromString<int>(s);
std::string str = ToString(i);

Werkt voor alle streambare typen (floats, enz.). Je moet #include <sstream>en mogelijk ook #include <string>.