hi, I am making a calculator and i need a function that can detect a char in a string. In other words, i need it to detect a NON-number.

``````string n1 = "35+66/7";
int pos = -1;
n1.find(char, pos+1);
cout << char.n1_find << " was found at "<< pos << endl;``````

I already know how to use the find function.

``n1.find("+", pos+1);``

but that wont work in my calculator. Any solutions?

## All 10 Replies

ok guys, i used find_first_not_of and the program works great. But there is only one problem. When i enter a digit larger than 9 and then add one, the answer doesnt come out right. I have reviewed it over and over and i cant see where im going wrong. Maybe you guys will have more luck than me.

``````#include <iostream>
#include <string>
#include<sstream>
using namespace std;

int main ()
{
string str ("1+10+1");
size_t found;
int n2, n11;
int l = 1, l1 = 1;
for(;;)
{
re:
found=str.find_first_not_of("12345678910");
if (int(found) != -1)
{
stringstream(str) >> n2;
str = str.substr(int(found+1));
if(l == 1)
{
n11 = n2;
l = 0;
goto re;
}

if(str[found] != '+')
{
re1:
n11 = n11 + n2;
}

}
else
{

stringstream(str) >> n2;
if(l1 == 1)
{

l1 = 0;
goto re1;
}
cout << "This is the finished number "<< n11 << endl;
system("pause");
break;
}
}

}``````

Is there a reason you are using `goto` ? It makes things much more complicated when trying to follow your logic. Also, and this is a personal preference thing, variable names such as l1, ll, nl1, nll and so on do not communicate much in the way of intent.

Here is an example that removes the `goto` from your example and simplifies the logic a bit

``````#include <iostream>
#include <string>
#include <sstream>

int main ()
{
std::string equation ("1+10+1"), saved = equation;
long running_sum = 0;

while (true) {
size_t non_digit = equation.find_first_not_of("0123456789");
std::string part = equation.substr (0,non_digit);
long value = 0;
std::stringstream(part) >> value;
running_sum += value;
if (non_digit == std::string::npos)
break;
equation = equation.substr(non_digit + 1);
}

std::cout << "Input  : " << saved << std::endl;
std::cout << "Result : " << running_sum << std::endl;
}``````

There is obviously plenty of error checking and other parts removed from the above but it will get you started on a non-goto approach at least.

ok, i just got rid of the first goto and it works great. Now, i cant figure out how to get the mathematical operations to work. I tried this:

``if(str[found] == '+')``

but that doesnt work. How would you do it?

How would you do it?

I'd start by removing all the `goto` s. From there I would look at the Shunting-Yard algorithm.

ok, i got rid of all the gotos. I figured out how to do the mathematical operations. Its just string operators = str[found]; And the only problem is the program wont loop right anymore. Heres is the code posted by L7Sqr with the mathematical operations:

``````#include <iostream>
#include <string>
#include <sstream>
using namespace std;
int main ()
{
std::string equation ("10+5-15+7-5-3"), saved = equation;
long running_sum = 0;
string operators = "";

while (true) {
size_t non_digit = equation.find_first_not_of("0123456789");
std::string part = equation.substr (0,non_digit);
long value = 0;
std::stringstream(part) >> value;
operators = equation[non_digit];

if(operators == "+")
{
running_sum += value;
}

if(operators == "-")
{
running_sum -= value;
}

if(operators == "*")
{
running_sum *= value;
}

if(operators == "/")
{
running_sum /= value;
}
if (non_digit == std::string::npos)
break;
equation = equation.substr(non_digit + 1);
}

std::cout << "Input  : " << saved << std::endl;
std::cout << "Result : " << running_sum << std::endl;
system("pause");
return 0;
}``````

Do you guys know whats wrong?

The problem is that you are passing the string in the wrong order. Consider just
the string "10-5". What you are doing is finding the first non-digit and setting that
to operator so you loop through doing `running_sum-=10` Then you ignore the last number:

What you need is a quick read of the first number and put it into the running_number,
and then find the operator etc

What you need is a quick read of the first number and put it into the running_number,
and then find the operator etc

Thats where i get stuck. I have tried over and over and i cant find the right code.

here guys. I finally finished a working calculator thats works with paranthesis, order of operations, and unlimited operators.

``````#include<iostream>
#include<string>
#include<sstream>
#include<windows.h>
#include<conio.h>
#include<ctime>
using namespace std;
int main ()
{
cout << "No variables." << endl;
cout << "Type in cls to clear the screen, and type exit to exit." << endl;
SetConsoleTitle("Calculator");
for(;;)
{
re:
string equation = "";
string equation2 = "";
string equation3 = "";
string equation4 = "";
string equation5 = "";
int non_digit5 = 0;
int non_digit2 = -1;
int non_digit6 = 0;
int c = 0;
int i = 0;
float n1 = 0;
string operators = "";
float n2 = 0;
cin >> equation;
DWORD ticks = GetTickCount();
if(equation == "exit")
{
return 0;
}

if(equation == "cls")
{
system("cls");
goto re;
}
while(true)
{
c = equation.find('(', c);
if(c == -1)
{
break;
}
//PARENTHESIS SOLVING CODE
do
{
non_digit2 = equation.find('(', non_digit2+1);
if(non_digit2 == -1)
{
break;
}
non_digit5 = non_digit2;
}while(non_digit2 != -1);
non_digit5 = non_digit5 + 1;
int non_digit3 = 0;
//DOUBLE PARANTHESIS EQUATIONS
equation4 = equation.substr(non_digit5, 999999999);
int l = equation.length();
int l1 = equation4.length();
non_digit3 = equation4.find(")", non_digit3+1);
l1 = l1 - non_digit3;
l = l - l1;
non_digit3 = l;
equation3 = equation.substr(non_digit3+1, 999999999);
equation2 = equation.substr(non_digit5, non_digit3);
do
{
non_digit2 = equation2.find(')', non_digit2+1);
if(non_digit2 == -1)
{
break;
}
non_digit6 = non_digit2;
}while(non_digit2 != -1);
equation2 = equation2.substr(0, non_digit6);
equation = equation.substr(0, non_digit5-1);
n1 = 0;
operators = "";
n2 = 0;
int non_digit = equation2.find_first_not_of("12345677890.");
string part = equation2.substr(0, non_digit);
stringstream(part) >> n1;
operators = equation2[non_digit];
equation2 = equation2.substr(non_digit + 1);
while(true)
{
n2 = 0;
non_digit = equation2.find_first_not_of("1234567890.");
part = equation2.substr (0, non_digit);
stringstream(part) >> n2;
if(int(non_digit) == 0)
{
string part = equation2.substr (0, non_digit+3);
stringstream(part) >> n2;
equation2 = equation2.substr(non_digit + 1);
}
if(operators == "+")
{
n1 = n1 + n2;
}

if(operators == "-")
{
n1 = n1 - n2;
}

if(operators == "*")
{
n1 = n1 * n2;
}

if(operators == "/")
{
n1 = n1 / n2;
}

if(non_digit == -1)
{
break;
}
non_digit = equation2.find_first_not_of("0123456789.");
operators = equation2[non_digit];
equation2 = equation2.substr(non_digit + 1);
}
stringstream out;
out << n1;
equation = equation + out.str();
equation = equation + equation3;
}
//ORDER OF OPERATIONS
while(true)
{
c = equation.find_first_not_of("1234567890.-+");
if(c == -1)
{
break;
}
equation2 = "";
equation3 = "";
equation4 = "";
operators = "";
float n1 = 0;
float n2 = 0;
float n3 = 0;
int non_digit = equation.find_first_not_of("1234567890.-+");
operators = equation[non_digit];
equation2 = equation.substr(non_digit+1, 999999999);
stringstream(equation2) >> n1;
equation3 = equation.substr(0,non_digit);
reverse(equation3.begin(), equation3.end());
//BEGIN FIXING REVERSED EQUATION
non_digit = equation3.find_first_not_of("1234567890.");
if(non_digit == -1)
{
reverse(equation3.begin(), equation3.end());
stringstream(equation3) >> n2;
}
else
{
equation5 = equation3.substr(0, non_digit);
reverse(equation5.begin(), equation5.end());
stringstream(equation5) >> n2;
}

stringstream out;
out << n2;
equation4 = equation4 + out.str();
equation4 = equation4 + operators;
stringstream out1;
out1 << n1;
equation4 = equation4 + out1.str();
//END OF FIND OPERATOR
int l = equation4.length();
non_digit = equation.find(equation4);
equation2 = equation.substr(0, non_digit);
equation4 = equation.substr(non_digit+l, 999999999);
if(operators == "/")
{
n3 = n2 / n1;
}
if(operators == "*")
{
n3 = n2 * n1;
}
stringstream out2;
out2 << n3;
equation2 = equation2 + out2.str();
equation2 = equation2 + equation4;
equation = equation2;
}
//START FIXED EQUATION SOLVING
n1 = 0;
operators = "";
n2 = 0;
size_t non_digit = equation.find_first_not_of("12345677890.");
string part = equation.substr (0, non_digit);
stringstream(part) >> n1;
operators = equation[non_digit];
equation = equation.substr(non_digit + 1);
while (true)
{
n2 = 0;
size_t non_digit = equation.find_first_not_of("1234567890.");
string part = equation.substr (0, non_digit);
stringstream(part) >> n2;
if(int(non_digit) == 0)
{
string part = equation.substr (0, non_digit+3);
stringstream(part) >> n2;
equation = equation.substr(non_digit + 1);
}
if(operators == "+")
{
n1 = n1 + n2;
}

if(operators == "-")
{
n1 = n1 - n2;
}

if(operators == "*")
{
n1 = n1 * n2;
}

if(operators == "/")
{
n1 = n1 / n2;
}

if (int(non_digit) == -1)
{
break;
}

non_digit = equation.find_first_not_of("0123456789.");
operators = equation[non_digit];
equation = equation.substr(non_digit + 1);
}
cout << "Speed of calculation: " << GetTickCount() - ticks << " milliseconds." << endl;
cout << "Result : " << n1 << endl;
system("pause");
goto re;
}
}``````
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, learning, and sharing knowledge.