I den här artikeln kommer du att lära dig om std::stol-funktionen i C++ med dess syntax och exempel.

Vad är std::stol()?

De Standard Template Library (STL) i C++ inkluderar std::stol() funktion, som är speciellt gjord för konvertering strängar till långa heltal . Denna funktion är särskilt användbar när man arbetar med användarinmatning eller läser data från externa källor - där inmatningen vanligtvis ges i strängformat. Den returnerar motsvarande långa heltal efter att ha tagit emot en sträng som indata. Ett undantag av typen std::invalid_argument eller std::out_of_range kastas om konverteringen inte är möjlig eller om inmatningssträngen innehåller tecken som inte är en del av ett giltigt tal.

Syntax:

Den har följande syntax:

long std::stol(const std::string& str, size_t* pos = 0, int bas = 10);

str: Texten som behöver ändras till ett långt heltal.

begränsningar för e-bankverksamhet

Pos: Indexet för strängens första okonverterade tecken, lagrat som en pekare till ett size_t-objekt. Om det inte krävs kan denna valfria parameter ställas in på nullptr.

bas: Omvandlingens numeriska bas. Tio är standard.

Returvärde: Det numeriska värdet som analyserades från inmatningssträngen returneras av funktionen som ett långt heltal.

Undantag: Funktionen ger ett undantag om konverteringen inte kan slutföras eller om tecken i inmatningssträngen är ogiltiga. Om ingen konvertering kunde göras, är de möjliga undantagen std::invalid_argument och std::out_of_range om det konverterade värdet är större än det representativa intervallet under en lång tid.

Användningsfall:

Inmatningsbearbetning av användare:

std::stol() är användbart för att omvandla numerisk indata som tas emot från användare i strängformat till en numerisk typ så att den kan bearbetas vidare.

In-/utgångsfil:

Läsa numeriska data i filer som innehåller strängar som data representation.

skillnaden mellan program och script

Datavalidering:

Datavalidering innebär att bekräfta att användarinmatningar korrekt representerar långa siffror genom att validera och verifiera dem.

Exempelprogram 1:

Låt oss ta ett exempel för att illustrera användningen av std::stol funktion i C++.

 #include #include int main() { std::string numStr = '12345'; try { long result = std::stol(numStr); std::cout << 'Converted value: ' << result << std::endl; } catch (const std::invalid_argument& e) { std::cerr << 'Invalid argument: ' << e.what() << std::endl; } catch (const std::out_of_range& e) { std::cerr << 'Out of range: ' << e.what() << std::endl; } return 0; } 

Produktion:

sträng till tecken

Förklaring:

Initialisering:
• En strängvariabel som kallas numStr initieras med värdet '12345' i början av programmet.
Prova blockera:
• Koden flyttas till ett försöksblock, vilket signalerar att den kommer att försöka köra satserna som finns i. Här behandlas eventuella undantag.
Konverteringsförsök:
• Programmet försöker använda std::stol() för att omvandla strängen numStr till ett långt heltal inuti försöksblocket.
Effektiv konvertering:
• Utfallet behålls i variabelresultatet om konverteringen lyckas.
Utdata konverterat värde:
• Det framgångsrika konverterade numret skrivs sedan ut till standardutdata av programmet.
Behandling av undantag:
• Ett av fångstblocken hanterar eventuella undantag som uppstår under konverteringen.
Undantag för att fånga ogiltiga argument:
• Ett felmeddelande om att argumentet är ogiltigt skrivs ut om undantaget är av typen std::invalid_argument.
Undantag för Catch Out of Range:
• Ett felmeddelande om att konverteringsresultatet ligger utanför det giltiga intervallet skrivs ut om undantaget är av typen std::out_of_range.
Returpolicy:
• Programmet returnerar 0 till operativsystemet, vilket betyder framgångsrik exekvering, och huvudfunktionen avslutas.

Kort sagt, koden försöker använda std::stol() funktion inuti ett försöksblock för att konvertera strängen '12345' till ett långt heltal. Resultatet skrivs ut om konverteringen lyckas. Den fångar upp undantag och skriver ut det relevanta felmeddelandet om ett sådant uppstår (antingen på grund av ett felaktigt argument eller på grund av att resultatet ligger utanför intervallet).

Slutligen returnerar programmet 0, vilket betyder framgångsrikt slutförande.

Exempelprogram 2:

Låt oss ta ett annat exempel för att illustrera användningen av std::stol funktion i C++.

 #include #include int main() { std::cout << 'Enter numeric strings to convert to long integers (type 'exit' to end):
'; while (true) { std::string userInput; std::cout <> userInput; if (userInput == 'exit') { std::cout << 'Exiting program. Goodbye!
'; break; } try { long result = std::stol(userInput); std::cout << 'Converted Value: ' << result << std::endl; } catch (const std::invalid_argument& e) { std::cerr << 'Error: Invalid argument in input '' << userInput << '': ' << e.what() << std::endl; } catch (const std::out_of_range& e) { std::cerr << 'Error: Out of range for input '' << userInput << '': ' << e.what() << std::endl; } } return 0; } 

Produktion:

Förklaring :

• I det här exemplet uppmanas användaren att ange strängvärden som ska konverteras.
• Applikationen kommer att fortsätta acceptera användarinmatning tills användaren matar in 'utgång' använder en while-loop.
Std::cin används inuti slingan för att läsa användarinmatning.
• Går in 'utgång' gör att detta program skriver ut ett avskedsmeddelande och avslutar slingan.
• Om inte, försöker den att använda std::stol för att konvertera ingången till en lång.
• Det konverterade värdet skrivs ut om konverteringen lyckas.
• Den fångar upp undantag (ogiltiga argument, utanför intervallet), skriver ut ett felmeddelande och fortsätter.
• När den väntar på ny användarinmatning går slingan vidare till nästa iteration.