Podcast: [ 11.mp3 ] is a reading of the Introduction below.

Introduction

This part of CompSci201 is all about functions. It covers Skansholm from section 4.2 to the end of chapter 4. First the text introduces the C++ way of coding procedure. Procedures are named pieces of code that you can write once and then use many times. They differ from typed functions in that they don't return a value and so they should not be used inside an expression. They are effectively a new home-made command that you have added to the C++ language. In this chapter the book develops a library of input/output procedures as examples. Page 120 shows how to use peek and get. Then comes the 'change_to' function for a character array. I have put the equivalent (and simpler) code for a vector on my web site (below). Similarly the code on page is a good example of the techniques but is written as a single statement if we use strings instead of a character array. However the code on page 122 for formatted output looks as it might be useful in several projects. You might like to input it, test it, and store it in your home directory.

Section 4.3 explains the ideas of scope and visibility -- where variables have particular meanings in you program. You will need to remember the rules if you want to avoid some surprising compile errors in the future. It also discusses a very nice feature of C++. You can have many functions with the same name as long as the have different types of parameters. The compiler picks the function that matches the call that have written.

Section 4.4 shows you how to split a function declaration from it definition. This can make programs easier to read. The real value of splitting the declaration form the body of a function is that you can now spread the code for a program into many files. This is described in section 4.5 but I think we can skip this in CS201. It is covered in CS202. However I have put a correction to the code on page 131 on the website.

Section 4.6 is vital. This introduces a new kind of parameter called a reference parameter. Other parameters are evaluated when the functions is called. Reference parameters are not copied. The call must provide a variable, and the code in the body of the function works with the variable you provide, not the one in the code. As a result any changes made to the variable actually change it. Now, we often need to do this... the book has some examples. There are many more. Notice the syntax. The presence of an ampersand (&) character makes the difference between a program that works and one that fails. I will be testing to see if you have learned this.

Section 4.6 describes a simple and useful feature of C++. You can provide a value for a parameter or argument in the declaration. If the call omits the parameters at the end then the compile provides values to fill out the call. A simple feature that you might not need in CS201.

The last section, section 4.8, gets into a very elegant, powerful, but somehow nerve racking feature of all modern (post 1960) programming languages. It is very simple: since you can call a function after it has been declared, you must be able to call it inside the body of the function. In other words the function is defined in terms of itself. Good programmers use this feature called "recursion" and it turns up in job interviews! In this class we will look at some examples and I may put one in a lab for you to play with. They become vital in CSCI202 and onward.

I have a good page of notes.... please look at those as well as reading the book. See you in class.

4.2 Functions that do not return a value

Defining a procedure (AKA void function):

 		void name ( arguments ) { body }

Using a procedure

 		name ( arguments );

Effect -- when the call is executed

1. The arguments are evaluated and passed to the arguments in the function body
2. The body executes
3. The computer jumps back to the next statement after the call.

page 119 -- output a new line

page 120 -- jump to start of next line of input

page 120 -- global change character in a text

This is useful for the old C strings. With the new C++ strings we would just write

 	void (string & s, char c, char cnew)

 	{  s.replace(0,s.size(), c, cnew);

 	}

page 121 -- inputting chars

This would be useful in the older C. It still makes a nice example of "look-ahead" with "peek" when reading data. Also notice the careful way that Skansholm tests for i<n-1 before anything else. Another subtle point: the careful addition of a null character at the end of the character array.

The bad news is that this function will do strange things if the person using it does not pre-allocate n+1 characters to there own array.

To input a word (any length) safely and simply in C++ use strings:

 		cin >> s;

page 122 -- formatted output

You might want to type in and test a copy of this function for your project work.

4.3 Declaration Scope and Visibility

page 123 -- multiple uses for variable names

Very useful -- especially when several people work on one program. Note -- most programming is a team effort.

My notes [ 10.html#Scope ] are on the web page for the previous class.

page 125 -- overloaded functions

A great convenience!

4.4 Function Declarations

 		type name ( arguments );

 		void name ( arguments );

You can spit the specification or declaration of a function (how to call it) from the definition/implementation of the function! The declaration tells the compiler what it needs to know about the function for you to be able to call it.

Recall: you can use a function any time after it is declared. So we can put all the details of how a function does things at the end of file as long we declare it before we use it.

Indeed we can precompile the complete definition of a function and link it into our program without recompiling it.

4.5 Division of Programs -- CS202

How to split up a big program into many small files.

Use on big projects. Used on all real projects. Used in CS202.

Lets skip it this quarter!

But please note the changes to the compiler commands on page 131. On Linux you would write

 		g++ -c main.cpp

 		g++ -c simpleio.cpp

 		g++ -o wordprog main.o simple.o

This is where Makefiles start to become a very useful tool.

4.6 Reference Parameters

Here are my notes on the three kinds of parameter/argument.

Pass by Value

The normal argument is an expression that is evaluated before the function is called. The resulting value is the initial value of the variable listed in the function header.

         type name (...., type argument, ....)

         void name (...., type argument, ....)

Pass by Reference

Some arguments are called by reference. These must be variables not expressions. They are not evaluated. The function is instead given the address of the variables and uses these in place of the symbol in the function header.

A call by reference is shown in the header by adding an ampersand symbol after the type:

         type name (...., type & argument, ....)

         void name (...., type & argument, ....)

Use this whenever you want a function to change the data owned by the calling program. If only one argument is changed think about making the function into one that returns the new value instead.

Pass by Constant Reference.

Call by Reference is the most efficient way to share complex data with a function. But, it also permits the function to change the arguments. This can make it difficult to find out what is going on in a program. It is therefore possible to indicate that an argument is called by reference but is safe from being changed:

         void name (...., const type & argument, ....)

         type name (...., const type & argument, ....)

Use this whenever the type is an array, vector, or any other type of object -- it the most efficient way to share complex data between the calling code and the subprogram. And the compiler will prevent the function from changing the shared data.

4.7 Parameters with default values

A new option in C++. Useful but not essential.

4.8 Recursive Functions

Recursive functions scare a lot of people -- but they work as well as any programming technique. First be sure you have a problem that is itself recursive. Second make sure you have a set of base values. Third make sure the the recursive calls move the arguments closer to the base values.

You may have heard of fractals -- these are all recursive functions.

page 140 -- classic factorial

page 143 -- the classic reverse function

Recursive functions are a topic of great interest in CSCI202 but we can probably take them lightly in CS201.

. . . . . . . . . ( end of section Reading) <<Contents | End>>

Project 4 is due.