Thread: Order of Operations Question

Just out of curiosity, in the code below, whenever the add(), sub(), mul(), and div() functions are called, do they return 0 after main() has been called, or do they function more like batch files in which until main() has finished or terminated the next line is not run in those functions?

For example:

Code:

@echo off
echo This program runs the windows calculator.
c:\windows\calc.exe
exit

In the batch file above, the exit command is not run until c:\windows\calc.exe has been terminated. Is this the same in C++?

Here is the code in question:

Code:

#include <iostream.h>
int add();
int sub();
int mul();
int div();
int main()
{
	int input;
	cout<<"Please select an operation:"<<endl;
	cout<<"1. Addition"<<endl;
	cout<<"2. Subtraction"<<endl;
	cout<<"3. Multiplication"<<endl;
	cout<<"4. Division"<<endl;
	cout<<"5. Exit"<<endl;
	cin>>input;
	switch (input)
	{
	case 1: add();
		break;
	case 2: sub();
		break;
	case 3: mul();
		break;
	case 4: div();
		break;
	case 5: return 0;
	}
}
int add()
{
	int x, y;
	cout<<"Please input two numbers to be added together."<<endl;
	cin>>x>>y;
	cout<<"The result is: "<<x+y;
	main();
	return 0;
}
int sub()
{
	int x, y;
	cout<<"Please input a number to be subtracted from another."<<endl;
	cin>>x>>y;
	cout<<"The resul is: "<<y-x;
	main();
	return 0;
}
int mul()
{
	int x, y;
	cout<<"Please input two numbers to be multiplied together."<<endl;
	cin>>x>>y;
	cout<<"The result is: "<<x*y;
	main();
	return 0;
}
int div()
{
	int x, y;
	cout<<"Please a number to be devided by another."<<endl;
	cin>>x>>y;
	cout<<"The result is: "<<x/y;
	main();
	return 0;
}

Sorry for the double post, but I was wondering if my tests were correct.

To see if return 0 was run after main() was called by the various add(), sub(), mul(), and div() functions, I tried the following in main().

Code:

cout<<"1. Addition"<<add()<<endl;

Now with that I should be able to see the output that the add() function creates, and a 0 on the end, because it outputs the returned value in the cout function. Though whenever I do this I get the normal output, and then no 0, and it runs the add() function again because a call to it is in main() which is called from add() (creating a never ending loop basically, thank god (bill gates, pun intended) for adding ctrl+c into DOS). So shouldn't that mean that return 0 in the add() function doesn't run until main() is terminated. Which means that return 0 in add() is never run because when main() is terminated then the entire program is terminated, or is it possible for code to execute after main() is terminated?

>don't use Macros when possible...
Generally good advice.

>it's usually better to return 0 than to return EXIT_SUCCESS...
I would love to hear why you think this. There's no valid reason to use one over the other, so clearly it's a stylistic issue. But I'd still be interested in seeing your reasoning.

>if you use a system command, people can easily make your code do bad things.
Not if the command is a string literal. It's just that system is godawful slow and takes up a considerable amount of resources compared to other methods.

>you also don't need the main() at the end of the void functions
Partly because calling main recursively is bad style and mostly because calling main recursively is illegal in C++.

>it's usually better to return 0 than to return EXIT_SUCCESS...
I would love to hear why you think this. There's no valid reason to use one over the other, so clearly it's a stylistic issue. But I'd still be interested in seeing your reasoning.

I've never seen EXIT_SUCCESS used and it serves no purpose other than to confuse other programmers, take up more memory for your code, and make you look pretentious. So don't waste your time typing it instead of 0.

>if you use a system command, people can easily make your code do bad things.
Not if the command is a string literal. It's just that system is godawful slow and takes up a considerable amount of resources compared to other methods.

ESPECIALLY if the command is a string literal. I don't know how often we tell people not to use system. It's not portable. Other OSs don't have a program in the default directory called pause. That's what system does - it actually executes the OS command that you put in parentheses, so if you don't have a pause program, you've got a problem. Someone can write a pause program, make it do something else, and then you still have a problem.

>you also don't need the main() at the end of the void functions
Partly because calling main recursively is bad style and mostly because calling main recursively is illegal in C++.

... and it's going to chew up resources and actually alter program flow. USE QUOTE TAGS!

I've never seen EXIT_SUCCESS used and it serves no purpose other than to confuse other programmers, take up more memory for your code, and make you look pretentious.

Have you ever seen EXIT_FAILURE? If not then the code you've been reading probably isn't portable. EXIT_SUCCESS is pretty obvious IMO as I can't begin to imagine how

Code:

return EXIT_SUCCESS;

or

Code:

exit(EXIT_SUCCESS);

could possibly be misinterpreted while the equivalent 0 would potentially be confusing if a reader didn't remember that 0 means success when terminating a program. The only confusing part would be the necessity of including <cstdlib>, but remembering that is no harder than remembering to include any other header for standard library use.

As for taking up space, yes it does take more keystrokes and result in an infintesimally larger source file, but the preprocessed file will probably end up with 0 anyway, and the effect on the executable will be nil. This cost is well worth it when you consider the added transparency of the source. Don't forget that we write code for more than just the compiler to read.

>It's not portable.
I don't know how I forgot to mention that, thanks. But I wasn't arguing in favor of using system, just in case you misinterpreted my comments.

>... and it's going to chew up resources and actually alter program flow.
If you mean the resources needed to throw a compiler error, yes. Calling main recursively is illegal in C++, the code won't compile if the compiler conforms properly to the standard.

Maybe so - but would you hire a programmer that didn't consider return 0 second nature? And does anyone know if cstdlib is going to cause the need for the compiler to link in a library you wouldn't have anyway? I didn't like that part of my Borland compiler so I'm afraid I never learnt enough about it to have this conversation... heh heh...

just in case you misinterpreted my comments.

Oh Ok. Well then just to re-echo what's his name - yes definately move away from system() calls. Another alternative is Sleep(1000) <-- where 1000 is the number of milliseconds. This call is to pause 1 second. It's in windows.h I believe.

And regarding the calls to main: Ahh - good point. My bad. But just so chix/w/guns understand the principle, since you can do the same thing by a function calling itself in a loop. It takes memory to have a function running. So if you function calls itself and gets in a loop that lasts more than a few iterations, you're very quickly going to have low resources.

Uhh... Whether it uses EXIT_SUCCESS or 0 does not affect portability, nor does using EXIT_FAILURE. By convention, 0 means success. Numerous programs have their own return codes to indicate different types of failures. And, it is not terribly difficult to remember that 0 means success.

>but would you hire a programmer that didn't consider return 0 second nature?
It depends on how they learned and how much experience they have. Standard C++ doesn't require main to return a value, defaulting to 0 when execution falls off the end. For programmers that spent a fraction of their time with main using standard C++ who then moved on to libraries and sections of code that don't use main, I can fully understand thinking of 0 as a failure code, and that can cause problems.

But yes, I would be a little wary if they saw

Code:

return 0;

and said "What does that mean?" In the end, it's a matter of style. I find both to be equally descriptive, but whenever I make use of EXIT_FAILURE, I use EXIT_SUCCESS for symmetry. Otherwise I opt for either 0 or no return statement at all depending on how lazy or pedantic I'm feeling at the time.

>And does anyone know if cstdlib is going to cause the need for the compiler to link in a library you wouldn't have anyway?
<cstdlib> is a standard header. As long as you don't use any non-portable extensions, you can include it and use its contents in any C++ program.

>so I'm afraid I never learnt enough about it to have this conversation... heh heh...
I guess that negates my heinous blunder in forgetting to mention that the argument to system was non-portable and pointing out how that could be a security issue. It would have saved me from a bad reputation marker and an embarrasing correction.

>Another alternative is Sleep(1000)
That wouldn't work too well for pausing the program before termination. One second isn't usually long enough for the user to read and process the output. You could make it several seconds, but users are big about control and like to stop the program whenever they feel godly. So something that breaks on user input is a good choice.

>It's in windows.h I believe.
Yes.

>gets in a loop that lasts more than a few iterations, you're very quickly going to have low resources.
How few "a few" is depends on the memory allocated to your process and remaining "stack" space for the activation records. Modern systems can have surprisingly deep recursive paths if the stack frame is relatively small. But recursion should be used judiciously despite that.

Originally Posted by Robc

It depends on how they learned and how much experience they have. Standard C++ doesn't require main to return a value, defaulting to 0 when execution falls off the end. For programmers that spent a fraction of their time with main using standard C++ who then moved on to libraries and sections of code that don't use main, I can fully understand thinking of 0 as a failure code, and that can cause problems.

On the other hand though, EXIT_SUCESS and EXIT_FALIURE doesn't say anything about what type of variable and what value it has, nor does it help any that they are declared elsewhere. Combine that with exit() instead of return, and you got yourself a real newbie confuser.

>Combine that with exit() instead of return, and you got yourself a real newbie confuser.
Heheh, fair enough. Thought it might be said that abstraction is a good thing for beginners. One could simply be told to define main as returning int and that EXIT_SUCCESS will work, without explaining why until a more suitable time. But to save myself from a mini holy war (sheer selfishness, I assure you), I'll say again that I feel it's a stylistic issue and leave it at that.