Wie kann ich umwandeln std::string zu int?

std::istringstream ss(thestring);
ss >> thevalue;

Werden richtig voll werden Sie wollen, überprüfen Sie die Fehler-flags.

Die möglichen Optionen sind unten beschrieben:

1. Erste option: sscanf()

    #include <cstdio>
    #include <string>

        int i;
        float f;
        double d;
        std::string str;

        //string -> integer
        if(sscanf(str.c_str(), "%d", &i) != 1)
            //error management

        //string -> float
        if(sscanf(str.c_str(), "%f", &f) != 1)
            //error management

        //string -> double 
        if(sscanf(str.c_str(), "%lf", &d) != 1)
            //error management

Ist dies ein Fehler (auch gezeigt durch cppcheck), weil "scanf ohne Feld Breite können Sie Grenzwerte Absturz mit riesigen input-Daten auf einigen Versionen von libc" (siehe hier, und hier).

2. Zweite option: std::sto*()

    #include <iostream>
    #include <string>

        int i;
        float f;
        double d;
        std::string str;

        try {
            //string -> integer
            int i = std::stoi(s);

            //string -> float
            float f = std::stof(s);

            //string -> double 
            double d = std::stod(s);
        } catch (...) {
            //error management
        }   

Diese Lösung ist kurz und elegant, aber es ist verfügbar nur auf auf C++11-konform Compiler.

3. Dritte option: sstreams

    #include <string>
    #include <sstream>

        int i;
        float f;
        double d;
        std::string str;

        //string -> integer
        std::istringstream ( str ) >> i;

        //string -> float
        std::istringstream ( str ) >> f;

        //string -> double 
        std::istringstream ( str ) >> d;

        //error management ??

Jedoch mit dieser Lösung ist schwer zu unterscheiden zwischen bad Eingang (siehe hier).

4. Vierte option: Erhöhung der lexical_cast

    #include <boost/lexical_cast.hpp>
    #include <string>

        std::string str;

        try {
            int i = boost::lexical_cast<int>( str.c_str());
            float f = boost::lexical_cast<int>( str.c_str());
            double d = boost::lexical_cast<int>( str.c_str());
            } catch( boost::bad_lexical_cast const& ) {
                //Error management
        }

Dies ist jedoch nur eine Hülle für sstream, und die Dokumentation empfiehlt die Verwendung sstrem für bessere Fehler-management (siehe hier).

5. Fünfte option: strto*()

Diese Lösung ist sehr lange, aufgrund von Fehler-management, und es ist hier beschrieben. Da es keine Funktion gibt eine nur int, eine Konvertierung ist erforderlich, im Falle von integer (siehe hier, wie diese Umwandlung erreicht werden kann).

6. Die sechste option: Qt

    #include <QString>
    #include <string>

        bool ok;
        std::string;

        int i = QString::fromStdString(str).toInt(&ok);
        if (!ok)
            //Error management

        float f = QString::fromStdString(str).toFloat(&ok);
        if (!ok)
            //Error management 

        double d = QString::fromStdString(str).toDouble(&ok);
        if (!ok)
    //Error management     

Schlussfolgerungen

Zusammenfassend kann man sagen, die beste Lösung ist C++11 std::es ist() oder-als zweite option, die Verwendung der Qt-Bibliotheken.
Alle anderen Lösungen sind entmutigt oder buggy.

Zugegeben, meine Lösung würde nicht funktionieren, für negative ganze zahlen, aber es wird extrahieren Sie alle positiven ganzen zahlen von der Eingabe von text mit Ganzzahlen. Es macht Gebrauch von numeric_only Gebietsschema:

int main() {
        int num;
        std::cin.imbue(std::locale(std::locale(), new numeric_only()));
        while ( std::cin >> num)
             std::cout << num << std::endl;
        return 0;
}

Input text:

 the format (-5) or (25) etc... some text.. and then.. 7987...78hjh.hhjg9878

Ausgabe von Ganzzahlen:

 5
25
7987
78
9878

Klasse numeric_only ist definiert als:

struct numeric_only: std::ctype<char> 
{
    numeric_only(): std::ctype<char>(get_table()) {}

    static std::ctype_base::mask const* get_table()
    {
        static std::vector<std::ctype_base::mask> 
            rc(std::ctype<char>::table_size,std::ctype_base::space);

        std::fill(&rc['0'], &rc[':'], std::ctype_base::digit);
        return &rc[0];
    }
};

Vollständige online-demo : http://ideone.com/dRWSj

atoi ist eine eingebaute Funktion, konvertiert einen string in einen integer, vorausgesetzt, dass die Zeichenfolge beginnt mit einem integer-Darstellung.

http://www.cplusplus.com/reference/clibrary/cstdlib/atoi/

Gut, viele Antworten, viele Möglichkeiten. Was ich hier vermisst wird einige Universelle Methode konvertiert einen string zu verschiedenen C++ - Integrale Datentypen (short, int, long, bool, ...).
Ich kam auf folgende Lösung:

#include<sstream>
#include<exception>
#include<string>
#include<type_traits>

using namespace std;

template<typename T>
T toIntegralType(const string &str) {
    static_assert(is_integral<T>::value, "Integral type required.");
    T ret;
    stringstream ss(str);
    ss >> ret;
    if ( to_string(ret) != str)
        throw invalid_argument("Can't convert " + str);
    return ret;
}

Hier sind einige Beispiele der Verwendung:

string str = "123";
int x = toIntegralType<int>(str); //x = 123

str = "123a";
x = toIntegralType<int>(str); //throws exception, because "123a" is not int

str = "1";
bool y = toIntegralType<bool>(str); //y is true
str = "0";
y = toIntegralType<bool>(str); //y is false
str = "00";
y = toIntegralType<bool>(str); //throws exception

Warum nicht einfach stringstream output-operator zur Konvertierung einer Zeichenfolge in einen ganzzahligen Typ?
Hier ist die Antwort:
Lassen Sie uns sagen, ein string enthält einen Wert, der den Grenzwert überschreitet, die für bestimmt sind integraler Typ. Unter anderem, auf Wndows 64 max int 2147483647.
Weisen Sie einen string-Wert max int + 1: string str = "2147483648".
Nun, beim konvertieren den string in eine int -:

stringstream ss(str);
int x;
ss >> x;

x wird 2147483647, was definitiv ein Fehler: string "2147483648" wurde nicht konvertiert werden soll, um die int 2147483647. Die bereitgestellte Funktion toIntegralType spots, solche Fehler zu und wirft die Ausnahme.

Einer Zeile version: long n = strtol(s.c_str(), NULL, base); .

(s ist der string, und base ist ein int wie 2, 8, 10, 16.)

Finden Sie in dieser link für mehr details strtol.

Den Kern der Idee ist die Verwendung strtol - Funktion, die enthalten ist in cstdlib.

Seit strtol nur Griffe mit char array, die wir brauchen, um zu konvertieren string zu char array. Sie können sich auf dieser link.

Beispiel:

#include <iostream>
#include <string>   //string type
#include <bitset>   //bitset type used in the output

int main(){
    s = "1111000001011010";
    long t = strtol(s.c_str(), NULL, 2); //2 is the base which parse the string

    cout << s << endl;
    cout << t << endl;
    cout << hex << t << endl;
    cout << bitset<16> (t) << endl;

    return 0;
}

die Ausgabe:

1111000001011010
61530
f05a
1111000001011010

ll toll(string a){
    ll ret=0;
    bool minus=false;
    for(auto i:a){
        if(i=='-'){ minus=true; continue; }
        ret*=10;
        ret+=(i-'0');
    } if(minus) ret*=-1;
    return ret;
    # ll is defined as, #define ll long long int
    # usage: ll a = toll(string("-1234"));
}