I am trying to compare to integer lengths in terms of their digit lengths, and padding out the smallest one with 0's so they are both the same size, ie:
6 and 1500
becomes
0006 and 1500
I cannot get std::stoi to work, to then check the length of each number.
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int schoolMethod(int a, int b, int base){
if(std::stoi(a)<std::stoi(b)){
//do stuff
return 0;
}
}
karatsuba.cpp: In function ‘int schoolMethod(int, int, int)’:
karatsuba.cpp:50: error: ‘stoi’ is not a member of ‘std’
stoi takes Const String as parameter, but here you are passing intto it.
Use std::to_string method to convert int into string and then compare their lengths.
If you want to convert your ints to strings to compare length, the following is a guide on how to basically do this.
std::to_string() will convert your ints to strings so you can then compare them.
string.length() will then return the length of the string.
#include <string>
int schoolMethod(int a, int b, int base){
std::string stringa = std::to_string(a); //convert to string
std::string stringb = std::to_string(b); //convert to string
if(stringa.length()<stringb.length()){ //compare string lengths
//do stuff
return 0;
}
}
Related
I created a program to convert a number into its binary format using a string(r), now I want to convert it into integer data type, I found atoi() function(import from cstdlib) on google for conversion from string to integer but its not working.
Here is my code- it shows error click here to see it
#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
int num,n;string r;
cout<<"Enter the number : ";
cin>>num;
while(num!=0){r = (num%2==0?"0":"1")+r;num/=2;}
cout<<"\nBinary value is "<<r<<endl;
n = atoi(r);
cout<<n;
return 0;
}
atoi() takes char arrays(ex. char xd[210]). If you wanna use strings, use stoi() instead.
atoi() expects a const char * (an array of char), where r is a std::string object. You can convert a string to const char * with it's c_str() method.
atoi(r.c_str())
I have code for using an array to create an ASCII table. I am having trouble compiling the code due to errors:
cannot convert 'char*' to char(*)[95] for argument '1' to void buildTable(char (8)[95], int)
and
cannot convert std::ofstream to char(*)[95] for argument '1' to 'void printTable(char(8)[95], int)
#include <iomanip>
#include <iostream>
#include <fstream>
int main () {
const int MAX_SIZE = 95;
char symbols[MAX_SIZE];
int values[MAX_SiZE], int values);
void buildTable (char [][MAX_SIZE], int values);
void printTable (char [][MAX_SIZE], int values);
void output(std::fstream, std::string, double);
std::string line;
std::ofstream outputFile;
outputFile.open("ascii.log");
if(outputFile.fail()) {
std::cout << "Error opening file. \n";
return 1;
}
else {
buildTable (symbols, values, MAX_SIZE);
printTable (outputFile, symbols, values, MAX_SIZE);
}
outputFile.close();
return 0;
}
The variable symbols is an array of char. It will decay to a pointer to its first element, &symbols[0], which will be of type char*.
The functions you declare takes its first parameter as a pointer to an array of char. A pointer to an array of char is very different from a pointer to char.
The solution is to make the function take the same data-type as you pass, i.e. a pointer to char, char*.
You also have multiple other problems. For example the functions you declare (buildTable and printTable) are currently declared to that this wrong argument as the first argument, and then int value as second argument. But that's not how you call those functions. You need to declare the functions with their actual arguments, and call them as declared.
On a related note: Since you program in C++ please don't use character arrays for strings, use std::string instead. It will save you a lot in the long run.
I am trying to pull a specific char from a string and convert it to an int. I have tried the following code, but I am unclear why it doesn't work nor can I find a way to do the conversion.
int value = 0;
std::string s = "#/5";
value = std::atoi(s[2]); // want value == 5
You can create std::string from one char and use std::stoi to convert to integer.
#include <iostream>
#include <string.h>
using namespace std;
int main() {
int value = 0;
string s = "#/5";
value = stoi(string(1, s[2])); //conversion
cout << value;
}
You can write:
std::string s = "#/5";
std::string substring = s.substr(2, 1);
int value = std::stoi(substring);
Using the substr method of std::string to pull out the substring that you want to parse as an integer, and then using stoi (which takes a std::string) instead of atoi (which takes a const char *).
You should read the manual page for atoi() more carefully. The actual prototype is:
int atoi(const char *string)
You are attempting to pass a single character rather than a pointer to a character array. In other words, by using s[2] you are dereferencing the pointer. You could, instead, use:
value = std::atoi(s+2);
or alternatively:
value = std::atoi(&s[2]);
This code doesn't dereference the pointer.
The argument to std::atoi must be char*, but s[2] is char. You need to use its address. And to get a valid C string from a std::string, you need to use the c_str() method.
value = std::atoi(&(s.c_str()[2]));
You should have gotten an error saying that the argument wasn't of the correct type.
This question already has answers here:
How to convert a number to string and vice versa in C++
(5 answers)
Closed 9 years ago.
#include <iostream>
using namespace std;
int main() {
string a = "1234"; //How this string convert in integer number
system("pause");
return EXIT_SUCCESS;
}
string a = "1234";
How this convert in integer
You can use std::stoi() to convert a std::string to an int.
#include <iostream>
#include <string>
int main() {
std::string a = "1234"; //How this string convert in integer number
int b = std::stoi(a);
system("pause");
return EXIT_SUCCESS;
}
If you have C++11 and onwards, use
int n = std::stoi(a);
(Pre C++11, you could use std::strtol;)
You could use boosts lexical cast
#include <boost/lexical_cast.hpp>
std::string str_num = "12345";
int value = 0;
try
{
value = boost::lexical_cast<int>(str_num);
}
catch(boost::bad_lexical_cast &)
{
// error with conversion - calling code will deal with
}
This way you can easily modify the code to deal with float or double if your string contains those types of numeric value also
You have to use std::stoi:
#include <iostream>
#include <string>
std::string s = "123";
int number= std::stoi(s);
The C++ Standard has a special function
int stoi(const string& str, size_t *idx = 0, int base = 10);
Probably you can try this
string a = "28787" ;
int myNumber;
istringstream ( a) >> myNumber;
See or you can search for stoi function and see how it can be used. Probably It can work but never try because I dont have the compiler of c++
Since this question gets asked about every week, this FAQ might help a lot of users.
How to convert an integer to a string in C++
how to convert a string into an integer in C++
how to convert a floating-point number to a string in C++
how to convert a string to a floating-point number in C++
Update for C++11
As of the C++11 standard, string-to-number conversion and vice-versa are built in into the standard library. All the following functions are present in <string> (as per paragraph 21.5).
string to numeric
float stof(const string& str, size_t *idx = 0);
double stod(const string& str, size_t *idx = 0);
long double stold(const string& str, size_t *idx = 0);
int stoi(const string& str, size_t *idx = 0, int base = 10);
long stol(const string& str, size_t *idx = 0, int base = 10);
unsigned long stoul(const string& str, size_t *idx = 0, int base = 10);
long long stoll(const string& str, size_t *idx = 0, int base = 10);
unsigned long long stoull(const string& str, size_t *idx = 0, int base = 10);
Each of these take a string as input and will try to convert it to a number. If no valid number could be constructed, for example because there is no numeric data or the number is out-of-range for the type, an exception is thrown (std::invalid_argument or std::out_of_range).
If conversion succeeded and idx is not 0, idx will contain the index of the first character that was not used for decoding. This could be an index behind the last character.
Finally, the integral types allow to specify a base, for digits larger than 9, the alphabet is assumed (a=10 until z=35). You can find more information about the exact formatting that can parsed here for floating-point numbers, signed integers and unsigned integers.
Finally, for each function there is also an overload that accepts a std::wstring as it's first parameter.
numeric to string
string to_string(int val);
string to_string(unsigned val);
string to_string(long val);
string to_string(unsigned long val);
string to_string(long long val);
string to_string(unsigned long long val);
string to_string(float val);
string to_string(double val);
string to_string(long double val);
These are more straightforward, you pass the appropriate numeric type and you get a string back. For formatting options you should go back to the C++03 stringsream option and use stream manipulators, as explained in an other answer here.
As noted in the comments these functions fall back to a default mantissa precision that is likely not the maximum precision. If more precision is required for your application it's also best to go back to other string formatting procedures.
There are also similar functions defined that are named to_wstring, these will return a std::wstring.
How to convert a number to a string in C++03
Do not use the itoa or itof functions because they are non-standard and therefore not portable.
Use string streams
#include <sstream> //include this to use string streams
#include <string>
int main()
{
int number = 1234;
std::ostringstream ostr; //output string stream
ostr << number; //use the string stream just like cout,
//except the stream prints not to stdout but to a string.
std::string theNumberString = ostr.str(); //the str() function of the stream
//returns the string.
//now theNumberString is "1234"
}
Note that you can use string streams also to convert floating-point numbers to string, and also to format the string as you wish, just like with cout
std::ostringstream ostr;
float f = 1.2;
int i = 3;
ostr << f << " + " i << " = " << f + i;
std::string s = ostr.str();
//now s is "1.2 + 3 = 4.2"
You can use stream manipulators, such as std::endl, std::hex and functions std::setw(), std::setprecision() etc. with string streams in exactly the same manner as with cout
Do not confuse std::ostringstream with std::ostrstream. The latter is deprecated
Use boost lexical cast. If you are not familiar with boost, it is a good idea to start with a small library like this lexical_cast. To download and install boost and its documentation go here. Although boost isn't in C++ standard many libraries of boost get standardized eventually and boost is widely considered of the best C++ libraries.
Lexical cast uses streams underneath, so basically this option is the same as the previous one, just less verbose.
#include <boost/lexical_cast.hpp>
#include <string>
int main()
{
float f = 1.2;
int i = 42;
std::string sf = boost::lexical_cast<std::string>(f); //sf is "1.2"
std::string si = boost::lexical_cast<std::string>(i); //sf is "42"
}
How to convert a string to a number in C++03
The most lightweight option, inherited from C, is the functions atoi (for integers (alphabetical to integer)) and atof (for floating-point values (alphabetical to float)). These functions take a C-style string as an argument (const char *) and therefore their usage may be considered a not exactly good C++ practice. cplusplus.com has easy-to-understand documentation on both atoi and atof including how they behave in case of bad input. However the link contains an error in that according to the standard if the input number is too large to fit in the target type, the behavior is undefined.
#include <cstdlib> //the standard C library header
#include <string>
int main()
{
std::string si = "12";
std::string sf = "1.2";
int i = atoi(si.c_str()); //the c_str() function "converts"
double f = atof(sf.c_str()); //std::string to const char*
}
Use string streams (this time input string stream, istringstream). Again, istringstream is used just like cin. Again, do not confuse istringstream with istrstream. The latter is deprecated.
#include <sstream>
#include <string>
int main()
{
std::string inputString = "1234 12.3 44";
std::istringstream istr(inputString);
int i1, i2;
float f;
istr >> i1 >> f >> i2;
//i1 is 1234, f is 12.3, i2 is 44
}
Use boost lexical cast.
#include <boost/lexical_cast.hpp>
#include <string>
int main()
{
std::string sf = "42.2";
std::string si = "42";
float f = boost::lexical_cast<float>(sf); //f is 42.2
int i = boost::lexical_cast<int>(si); //i is 42
}
In case of a bad input, lexical_cast throws an exception of type boost::bad_lexical_cast
In C++17, new functions std::to_chars and std::from_chars are introduced in header charconv.
std::to_chars is locale-independent, non-allocating,
and non-throwing.
Only a small subset of formatting policies used by
other libraries (such as std::sprintf) is provided.
From std::to_chars, same for std::from_chars.
The guarantee that std::from_chars can recover
every floating-point value formatted
by to_chars exactly is only provided if both
functions are from the same implementation
// See en.cppreference.com for more information, including format control.
#include <cstdio>
#include <cstddef>
#include <cstdlib>
#include <cassert>
#include <charconv>
using Type = /* Any fundamental type */ ;
std::size_t buffer_size = /* ... */ ;
[[noreturn]] void report_and_exit(int ret, const char *output) noexcept
{
std::printf("%s\n", output);
std::exit(ret);
}
void check(const std::errc &ec) noexcept
{
if (ec == std::errc::value_too_large)
report_and_exit(1, "Failed");
}
int main() {
char buffer[buffer_size];
Type val_to_be_converted, result_of_converted_back;
auto result1 = std::to_chars(buffer, buffer + buffer_size, val_to_be_converted);
check(result1.ec);
*result1.ptr = '\0';
auto result2 = std::from_chars(buffer, result1.ptr, result_of_converted_back);
check(result2.ec);
assert(val_to_be_converted == result_of_converted_back);
report_and_exit(0, buffer);
}
Although it's not fully implemented by compilers, it definitely will be implemented.
I stole this convienent class from somewhere here at StackOverflow to convert anything streamable to a string:
// make_string
class make_string {
public:
template <typename T>
make_string& operator<<( T const & val ) {
buffer_ << val;
return *this;
}
operator std::string() const {
return buffer_.str();
}
private:
std::ostringstream buffer_;
};
And then you use it as;
string str = make_string() << 6 << 8 << "hello";
Quite nifty!
Also I use this function to convert strings to anything streamable, althrough its not very safe if you try to parse a string not containing a number;
(and its not as clever as the last one either)
// parse_string
template <typename RETURN_TYPE, typename STRING_TYPE>
RETURN_TYPE parse_string(const STRING_TYPE& str) {
std::stringstream buf;
buf << str;
RETURN_TYPE val;
buf >> val;
return val;
}
Use as:
int x = parse_string<int>("78");
You might also want versions for wstrings.
#include <iostream>
#include <string.h>
using namespace std;
int main() {
string s="000101";
cout<<s<<"\n";
int a = stoi(s);
cout<<a<<"\n";
s=to_string(a);
s+='1';
cout<<s;
return 0;
}
Output:
000101
101
1011