(C) Theodore Norvell 1999
What is the result of this function
int foo(int j) {
int x = 5 ;
if( j == 0 ) {
int x ;
x = 3 ; }
return x ;
}
There is an assignment of 3 to a variable named x, but that variable is different from the one whose value is consulted on the return from the function.
The assignment of 3 to the "inner" variable named "x" has no effect on the value of the "outer" variable also named "x". It is an entirely different variable. It is possible to have more than one variable in existence at the same time with the same name.
There is an assignment of 3 to a variable named x, but that variable is different from the one whose value is consulted on the return from the function.
What value is returned from a call to subroutine f?
int fred = 0;
void g(int fred) {
fred = 13 ;
}
int f() {
int fred = 42 ;
g( fred ) ;
return fred ;
}
The global variable named "fred" is a red-herring.
The variable named "fred" in subroutine "g" is a different variable from the variable named "fred" in subroutine "f". So the assignment within "g" has no effect on the variable declared in "f"
The variable named "fred" in subroutine "g" is a different variable from the variable named "fred" in subroutine "f". So the assignment within "g" has no effect on the variable declared in "f"
Try again.
What value is returned from a call to subroutine f?
int fred = 0;
void g(int &frieda) { // This line is different from last time.
frieda = 13 ; // So is
this one
}
int f() {
int fred = 42 ;
g( fred ) ;
return fred ;
}
The global variable "fred" is a red-herring.
This time the parameter to "g" is a reference parameter. This means that it is like another name for the argument variable. In this case the argument variable is "fred" in subroutine "f". The assignment to "frieda" does not change "frieda" (it remains a reference to the same variable), but rather changes "fred" to 13.
Note the & in the declaration of "frieda". It indicates a reference parameter.
Try again.
What values are printed by this program?
#include <iostream>
using namespace std ;
int nutsy(bool flag) {
int fred ;
if( flag ) fred = 42 ;
return fred ; }
int main() {
cout << nutsy( true ) << endl ;
cout << nutsy( false ) << endl ; }
You can not rely on stack variables being initialized to 0.
The second time that "nutsy" is called, the variable "fred" is not initialized. It is important to understand that every call to a subroutine gets different variables. The lifetime of the first "fred" variable ended when the first subroutine call ended.
The variable "fred" is not initialized, the second time "nutsy" is called. There is no telling what value it has. It may have the value 42, but it may not.
It's fairly clear the first statement in main will output a 42..
What is printed by this program
#include <iostream>
#include <new>
using namespace std ;
int main() {
int *p = new(nothrow) int ;
if( p!=0 ) {
*p = 99 ;
int *q = p ;
delete q ;
cout << *p << endl ; }
}
It is possible that it prints 99. But you can not count on it.
Try again.
The line cout << *p dereferences a pointer p. But the variable p used to point to was destroyed by the delete statement. If you try to use a variable that has been destroyed, there is no telling what will happen. In some cases your program will crash; in others it will behave oddly; sometimes nothing strange happens at all.
What is printed by this program
#include <iostream>
#include <new>
using namespace std ;
int main() {
int *p = new(nothrow) int ;
if( p!=0 ) {
delete p ;
*p = 99 ;
cout << 12 << endl ; }
}
Try again
It is possible that it prints 12. But you can not count on it.
As in the last question, there is an attempt to use a variable that no longer exists.
The program may crash, but you can not count on it. More often when you assign to a variable that has been destroyed already, the assignment is made to some other variable. Bugs like that are very hard to track down.