Functions
Building blocks of a C++ program Each function has a name, which is
used to call the function; functions call each other
You will write your own functions, e.g. main(), and also use pre-written functions from standard library
/* This program contains two functions: main() and myfunc().*/#include <iostream.h>
void myfunc(); // myfunc's Protoype
int main(){ cout << "In main()"; myfunc(); // call myfunc() cout << "Back in main()";
return 0;}
void myfunc() // myfunc’s Definition{ cout << " Inside myfunc() ";}
Function Prototypevoid myfunc(); // myfunc's Protoype Like variable declaration; tells the compiler about
the return type of the function and the number and type of parameters it needs from the calling function:
return_type functionName (parameter list); So, place prototypes before main() main() is predefined in C++ and does not need
a prototype Can’t the compiler look ahead and get
definitions? Prototype can be omitted if whole function
placed before it is called; is that a good practice?
Returning a Value
// Returning a value.
#include <iostream.h>
int mul(int x, int y); // mul()'s prototype
int main(){ int answer; answer = mul(10, 11); // assign return value cout << "The answer is " << answer; return 0;}
// This function returns a value. int mul(int x, int y){ return x * y; // return product of x and y}
Library Functions Pre-written functions in libraries that you
can use Just include the proper header file Compiler gets prototype from the header
file and searches appropriate libraries itself to get function definition
e.g. math library has mathematical functions in it
#include <iostream.h>#include <math.h> //or <cmath>
int main(){ cout << sqrt(9.0); return 0;}
Scope Rules
Scope rules tell that a variable is visible to which parts of your program; also define variable’s lifetime
3 types of variables: local, global, formal parameters
Scope Rules - Local Variables
A variable can be declared inside any block and is then local to that block
Block: {} int main() { {int x = 4;} cout << x; return 0; }
error C2065: 'x' : undeclared identifier Memory storage for a local variable created
when entering its block and destroyed when its block exited
Scope Rules-Local Variables Most common block is a function
#include <iostream.h>void func();int main(){ int x; // local to main() x = 10; func(); cout << x; // displays ? return 0;}void func(){ int x; // local to func() x = -199; cout << x; // displays ?}
-199 10. Each variable x has a separate location in memory
Identically-named variables in inner block ‘hide’ or override those in the outer block; Avoid this practice
Scope Rules-Local Variables #include <iostream.h> int main() { int i, j; i = 10; j = 100; if(j > 0) { // start of block int i; // this i is separate from outer i i = j / 2; // outer j is known here cout << “first inner i: " << i << '\n'; } if(i < 50) { i += 10; cout << “2nd inner i: “ << i << endl;
} cout << "outer i: " << i << '\n'; return 0; }50 20 20 Declaring within a conditional block also saves memory; see next
slide
Scope Rules-Local Variables
int main() { int choice; cout << "(1) add numbers or "; cout << "(2) concatenate strings?: "; cin >> choice;
if(choice == 1) { int a, b; /* activate two integer vars */ cout << "Enter two numbers: "; cin >> a >> b; cout << "Sum is " << a+b << '\n'; } else { char s1[80], s2[80]; /* activate two strings */ cout << "Enter two strings: "; cin >> s1; cin >> s2; strcat(s1, s2); cout << "Concatenation is " << s1 << '\n'; } a = 10; // *** Error *** -- a not known here! return 0; }
Scope Rules-Local Variables
Variables declared in for loops are local according to current spec for C++
for(int i = 0; i<10; i++) cout << i << " "; i = 100; // *** Error *** -- i not known here!
Does not work on Visual C++ 6.0 (i.e. no error)
Can declare a variable within any conditional expression
if(int x = 20) { cout << "This is x: "; cout << x;}
x = 2; //*** Error *** -- x not known here!
Not a good practice
Scope Rules-Formal Parameters
Formal parameters: variables that receive values passed to a function
Scope local to the function #include <iostream.h> int mult(int, int); int main() { int a = 10, b = 20; cout << mult(a, b); //cout << x << y; // *** Error *** --unknown identifiers x, y
return 0; }
int mult(int x, int y)// can have different names here { return x*y; }
Scope Rules-Global Variables
Usually declared outside any function; have life as long as the program runs
Can be used by all following functions Usually placed at the beginning of
program Initialized only at the start of the program;
uninitialized default to zero An identically named local variable masks
global one
Scope Rules-Global Variables #include <iostream.h> void func();
int i = 2; // global int main() { cout << i << endl; func(); cout << i << endl; int i = 5; // local. What if i=5; cout << i << endl; func(); return 0; } void func() { cout << i << endl; int i = 3; // local cout << i << endl; } 2 2 3 2 5 2 3 2 2 3 2 5 5 3 if i = 5 at the indicated place
Scope Rules-global variables
#include <iostream.h> #include <cstdlib> void drill(); int count; //count and num_right
are global int num_right; int main() { cout << "How many practice
problems: "; cin >> count; num_right = 0; do { drill(); count--; } while(count); cout << "You got " <<
num_right << “ right.\n"; return 0; }
void drill() { int count; /* This count is local. */ int a, b, ans; // Generate two numbers between 0
and 99. a = rand() % 100; b = rand() % 100; // The user gets three tries to get it
right. for(count=0; count<3; count++) { cout << "What is " << a << " + " <<
b << "? "; cin >> ans; if(ans==a+b) { cout << "Right\n"; num_right++; return; } } cout << "You've used up all your
tries.\n"; cout << "The answer is " << a+b <<
'\n'; }
Passing Pointers to Functions
No big deal. Just declare parameter as type _______ ?
#include <iostream.h> void f(int *j);//or void f(int *); int main() { int i; int *p; p = &i; // p now points to i f(p); cout << i; // i is now 100 return 0; } void f(int *j) { *j = 100; // var pointed to by j is assigned 100 }
i26
p j
100
100 100
Passing Pointers to Functions The pointer variable not necessary. Can generate
and pass the address of i as such to f()
#include <iostream.h> void f(int *j); int main() { int i; f(&i); cout << i; return 0; } void f(int *j) { *j = 100; // var pointed to by j is assigned 100 }
i26
j
100
100
Passing Pointers to Functions #include <iostream.h> int sqr_it(int x); int main() { int t=10; cout << sqr_it(t) << ' ' << t; //output? } int sqr_it(int x) { x = x*x; return x;} IMPORTANT: What’s the difference between the
above function, and the ones on previous two slides?
Here, a copy of the value of t is passed. t remains unaltered. x is a local variable, which could have been named t
Called “Call by Value” Previous called “Call by Reference” where the
original variable (not a copy) is accessed by the called function
(copy)t5 5
5x
Passing Arrays to Functions What is an array name without index? Address of first element passed to function.
So actual array accessed, not a copy. Saves memory
3 ways to pass this addressI. Declare parameter as an array of same type
and size #include <iostream.h> void display(int num[10]); //or display(int [10]); int main() { int t[10],i; for(i=0; i<10; ++i) t[i]=i; display(t); // pass array t to a function cout <<endl; for(i=0; i<10; i++) cout << t[i] << ' '; //output? } // Print some numbers. void display(int num[10]) { int i; for(i=0; i<10; i++) cout << num[i] << ' '; //output? for(i=0; i<10; i++) (num[i] = num[i] + 1); }
Passing Arrays to FunctionsII. Can also declare as display(int num[]) i.e. unsized.
Same thing Internally, compiler converts int num[10] or int num[] to
int *III. So, why not declare parameter as a pointer to int void display(int *num) { int i; for(i=0; i<10; i++) cout << num[i] << ' '; //or *(num+i) } How is a single element passed? As an ordinary variable #include <iostream.h> void display(int num); //each element is of type int int main() { int t[10],i; for(i=0; i<10; ++i) t[i]=i; for(i=0; i<10; i++) display(t[i]); //only one element passed } void display(int num) { cout << num << ' ';}
Passing Arrays to Functions #include <iostream.h> void cube(int *n, int num); int main() { int i, nums[10]; for(i=0; i<10; i++) nums[i] = i+1; cout << "Original contents: "; for(i=0; i<10; i++) cout << nums[i] << ' '; cout << '\n'; cube(nums, 10); // compute cubes cout << "Altered contents: "; for(i=0; i<10; i++) cout << nums[i] << ' '; return 0; } void cube(int *n, int num) {
while(num) { *n = *n * *n * *n; num--; n++; } } Original contents: 1 2 3 4 5 6 7 8 9 10 Altered contents: 1 8 27 64 125 216 343 512 729 1000
Passing Strings to Functions What is a string stored as? So what should we
pass?
#include <iostream.h> #include <cstring> #include <cctype> void stringupper(char *str); int main() { char str[80]; strcpy(str, "this is a test"); stringupper(str); cout << str; // display uppercase string return 0; } void stringupper(char *str) { while(*str) { *str = toupper(*str); // uppercase one char str++; // move on to next char } } Can also declare as an array of char
stringupper(char[])
The return Statement return statement can be used without a value for
void functions. Must return a value for non-void functions
Control passed back to calling function when return encountered or closing curly brace of function
#include <iostream.h> void power(int base, int exp); int main() { power(2, 10); return 0; } void power(int base, int exp) { int i; if(exp<0) return; i = 1; for( ; exp; exp--) i = base * i; cout << "The answer is: " << i << endl; }
The return Statement Can have multiple return statements.
Function returns as soon as the first one encountered
void f() { // ... switch(c) { case 'a': return; case 'b': // ... case 'c': return; } if(count<100) return; // ... }
The return Statement non-void functions return values to the calling
function. Therefore, can call a non-void function and use that call as an operand in an expression (as it has a value) in the calling function
x = power(y); if(max(x, y)) > 100) cout << "greater"; switch(abs(x)) {...
Don’t necessarily have to store the returned value in a variable
#include <iostream.h> #include <cstdlib> int main() { int i; i = abs(-10); // stored cout << abs(-23); // just used abs(100); // returned value discarded return 0; }
Multiple return Statements #include <iostream.h> int find_substr(char *sub, char *str); int main() { int index; index = find_substr("three", "one two
three"); cout << "Index of three is " <<
index; // index is 8 return 0; }
int find_substr(char *sub, char *str){ int t; char *p, *p2;
for(t=0; str[t]; t++) { p = &str[t]; // reset pointers p2 = sub; while(*p2 && *p2==*p) { // check for substring p++; p2++; } /* If at end of p2 (i.e.,
substring), then a match has been found. */
if(!*p2) return t; // return index
//of match
} return -1; // no match found }
Returning Pointers
#include <iostream.h> char *get_substr(char *sub, char *str); int main() { char *substr; substr = get_substr("three", "one two
three four"); cout << "substring found: " <<
substr; return 0; }
char *get_substr(char *sub, char *str)
{int t;char *p, *p2, *start;
for(t=0; str[t]; t++) { p = &str[t]; // reset pointers start = p; p2 = sub;
while(*p2 && *p2==*p) { //check for substring
p++; p2++;
} /* If at end of p2 (i.e.,
substring), then a match has been found. */
if(!*p2) return start; /* return
pointer to beginning of substring */
} return 0; // no match found
}
Command Line Arguments To pass info to main() from the command line e.g. cl hellouser Here, cl and hellouser are command line
arguments main() receives infor about these arguments in two
parameters:int main( int argc, char *argv[])
argc (argument count) parameter is an integer that holds the number of arguments on the command line. Always at least 1, as program name also counted
argv (argument variable) parameter is a null-terminated array of pointers to strings
argv[0] points to program name on command line, argv[1] points to the first argument, and so on. argv[argc]==0
Command Line Arguments #include <iostream.h> int main(int argc, char *argv[]) { if(argc!=2) { cout << "You forgot to type your name.\n"; return 1; } cout << "Hello " << argv[1] << '\n'; return 0; }
If we name this program as greeting, then after making an exe file we can type greeting Shamail at the command prompt and the program will execute and output: Hello Shamail
Spaces and tabs usually separate strings; for a longer string, use quotes e.g. greeting “Shafay Shamail” outputs Hello Shafay Shamail
Command Line Arguments Can access individual characters in the command line
strings by using a double subscript. See the program echo below
#include <iostream.h> int main(int argc, char *argv[]) { int t, i; for(t=0; t<argc; ++t) {// t denotes the tth string i = 0; while(argv[t][i]) {// t[i] accesses the ith character of t cout << argv[t][i]; ++i;
cout << ' '; }
cout << ' '; } return 0; } e.g. echo hi there results in e c h o h i t h e r e
Passing Numeric Command Line Arguments
Want to pass numbers to main( ), but it takes strings
Use atof(), atoi(), atol() #include <iostream.h> #include <cstdlib> int main(int argc, char *argv[]) { double a, b; a = atof(argv[1]); b = atof(argv[2]); cout << a + b; return 0; }
atoi(“2”) gives 2; atof(“-11.11”) gives -11.11
Command Line Arguments
#include <iostream.h> #include <cstdlib> int main(int argc, char *argv[]) { double a, b; a = atof(argv[1]); b = atof(argv[2]); cout << a + b; return 0; }
#include <iostream.h> int main(int argc, char *argv[]) { while(--argc > 0)
cout << *++argv << endl; return 0; }
#include <iostream.h> int main(int argc, char *argv[]) { for(int j=0; j<argc; j++)
cout << argv[j] << endl; return 0; }
#include <iostream.h> #include <cstdlib> int main(int argc, char *argv[]) { char **argvector = argv; double a, b; a = atof(*++argvector); b = atof(*++argvector); cout << a + b; return 0; }
Top Related