Functions and recursion - Revision history

wikademia>Eme: moved Beta:Functions and recursion to Functions and recursion over redirect

2009-11-08T23:08:44Z

moved Beta:Functions and recursion to Functions and recursion over redirect

← Older revision	Revision as of 23:08, 8 November 2009
(No difference)

wikademia>Wikademia: moved Functions and recursion to Beta:Functions and recursion

2009-06-08T23:11:06Z

moved Functions and recursion to Beta:Functions and recursion

← Older revision	Revision as of 23:11, 8 June 2009
(No difference)

wikademia>Wikademia: moved Functions and Recursion to Functions and recursion

2009-06-04T05:38:14Z

moved Functions and Recursion to Functions and recursion

← Older revision	Revision as of 05:38, 4 June 2009
(No difference)

wikademia>Wikademia at 19:10, 18 May 2009

2009-05-18T19:10:38Z

← Older revision		Revision as of 19:10, 18 May 2009
Line 1:		Line 1:
	This lesson will have to do with using functions and recursion to improve readability and efficiency of your code. This lesson assumes you have a general grasp of C++ syntax. Other than that, I will explain everything as well as I can.		This lesson will have to do with using functions and recursion to improve readability and efficiency of your code. This lesson assumes you have a general grasp of C++ syntax. Other than that, I will explain everything as well as I can.
			{{?}}
	==Functions==		==Functions==
	Simply put a function is a segment of code that is isolated from the main code segment. A function is ''called'' from a section of code. When the function's code has been executed, it ''returns'' to the calling code. The general form of a function is:		Simply put a function is a segment of code that is isolated from the main code segment. A function is ''called'' from a section of code. When the function's code has been executed, it ''returns'' to the calling code. The general form of a function is:

wikademia>Wikademia: 14 revisions

2009-04-11T05:40:44Z

14 revisions

← Older revision	Revision as of 05:40, 11 April 2009
(No difference)

wikademia>Miklcct: corrected some terms

2009-04-10T12:41:45Z

corrected some terms

← Older revision		Revision as of 12:41, 10 April 2009
Line 104:		Line 104:
	}		}
	</pre>		</pre>
	There are many things to note in this example. First is the use of the two prototypes that precede the <tt>main<tt> function. They allow <tt>main<tt> to use <tt>fctn1<tt> and <tt>fctn2<tt> even though they aren't ~~declared~~ until after <tt>main<tt>.		There are many things to note in this example. First is the use of the two prototypes that precede the <tt>main<tt> function. They allow <tt>main<tt> to use <tt>fctn1<tt> and <tt>fctn2<tt> even though they aren't defined until after <tt>main<tt>.

	Next, notice that to call <tt>fctn1<tt> all we had to do was enter <tt>fctn1();<tt>. Since it doesn't require any arguments and it has a <tt>void<tt> return value, this is very simple. For <tt>fctn2<tt> however, we see that it not only requires two arguments, but also returns an integer as well. To pass data to a function, you simply list the data in the order it is called for by the function definition. To catch the returned data, we use the assignment operator '=' and assign the returned value to a variable <tt>sum<tt>.		Next, notice that to call <tt>fctn1<tt> all we had to do was enter <tt>fctn1();<tt>. Since it doesn't require any arguments and it has a <tt>void<tt> return value, this is very simple. For <tt>fctn2<tt> however, we see that it not only requires two arguments, but also returns an integer as well. To pass data to a function, you simply list the data in the order it is called for by the function definition. To catch the returned data, we use the assignment operator '=' and assign the returned value to a variable <tt>sum<tt>.

wikademia>Steaxauce: /* Scope */

2008-05-27T05:29:06Z

Scope

← Older revision		Revision as of 05:29, 27 May 2008
Line 162:		Line 162:

	===Scope===		===Scope===
	Scope refers to the level of access an object has. A function can access only global variables and those that are passed to it through arguments. Also, any ~~variable~~ declared inside a function are only available to that function.		Scope refers to the level of access an object has. A function can access only global variables and those that are passed to it through arguments. Also, any variables declared inside a function are only available to that function.
	For example, an integer declared in <tt>main<tt> will not be available to any other function unless it is passed as an argument. Vis versa, an integer declared in a function will not be available to the <tt>main<tt> function.		For example, an integer declared in <tt>main<tt> will not be available to any other function unless it is passed as an argument. Vis versa, an integer declared in a function will not be available to the <tt>main<tt> function.

68.230.162.132: /* Recursion */

2008-03-31T22:56:56Z

Recursion

← Older revision		Revision as of 22:56, 31 March 2008
Line 193:		Line 193:
	:::*<tt>factorial(1)<tt> returns 1 so <tt>factorial(2)<tt> can return 2×1...2		:::*<tt>factorial(1)<tt> returns 1 so <tt>factorial(2)<tt> can return 2×1...2
	::*<tt>factorial(2)<tt> returns 2 so <tt>factorial(3)<tt> can return 3×2...6		::*<tt>factorial(2)<tt> returns 2 so <tt>factorial(3)<tt> can return 3×2...6
	:*<tt>factorial(3)<tt> returns 6 so <tt>factorial(4)<tt> can return 4×3...24		:*<tt>factorial(3)<tt> returns 6 so <tt>factorial(4)<tt> can return 4×6...24

	Many times, a recursive solution to a problem is very easy to program. The drawback of using recursion is that there is a lot of overhead. Every time a function is called, it is placed in memory. Since you don't exit the <tt>factorial<tt> function until n reaches 1, n functions will reside in memory. This isn't a problem for the simple factorial(4), but other functions can lead to serious memory requirements.		Many times, a recursive solution to a problem is very easy to program. The drawback of using recursion is that there is a lot of overhead. Every time a function is called, it is placed in memory. Since you don't exit the <tt>factorial<tt> function until n reaches 1, n functions will reside in memory. This isn't a problem for the simple factorial(4), but other functions can lead to serious memory requirements.

210.55.245.178: /* The `main Function */`

2007-08-27T23:00:17Z The <tt>main<tt> Function ← Older revision Revision as of 23:00, 27 August 2007 Line 26: Line 26: ===The <tt>main<tt> Function=== ===The <tt>main<tt> Function=== The <tt>main<tt> function is a special function. Every C++ program must contain a function named "main". It serves as the entry point for the program. The computer will start running the code form the beginning of the main function. The <tt>main<tt> function is a special function. Every C++ program must contain a function named "main". It serves as the entry point for the program. The computer will start running the code from the beginning of the main function. There are two main types of <tt>main<tt> functions; one with and one without parameters. Below are examples of both: There are two main types of <tt>main<tt> functions; one with and one without parameters. Below are examples of both: <pre> <pre>

122.161.30.89: /* Functions */ 2007-08-04T11:56:33Z Functions ← Older revision Revision as of 11:56, 4 August 2007 Line 2: Line 2: ==Functions== ==Functions== Simply put, a function is a segment of code that is isolated from the main code segment. A function is ''called'' from a section of code. When the function's code has been executed, it ''returns'' to the calling code. The general form of a function is: Simply put a function is a segment of code that is isolated from the main code segment. A function is ''called'' from a section of code. When the function's code has been executed, it ''returns'' to the calling code. The general form of a function is: :{| :{|

← Older revision		Revision as of 23:00, 27 August 2007
Line 26:		Line 26:

	===The <tt>main<tt> Function===		===The <tt>main<tt> Function===
	The <tt>main<tt> function is a special function. Every C++ program must contain a function named "main". It serves as the entry point for the program. The computer will start running the code ~~form~~ the beginning of the main function.		The <tt>main<tt> function is a special function. Every C++ program must contain a function named "main". It serves as the entry point for the program. The computer will start running the code from the beginning of the main function.
	There are two main types of <tt>main<tt> functions; one with and one without parameters. Below are examples of both:		There are two main types of <tt>main<tt> functions; one with and one without parameters. Below are examples of both:
	<pre>		<pre>

← Older revision		Revision as of 11:56, 4 August 2007
Line 2:		Line 2:

	==Functions==		==Functions==
	Simply put, a function is a segment of code that is isolated from the main code segment. A function is ''called'' from a section of code. When the function's code has been executed, it ''returns'' to the calling code. The general form of a function is:		Simply put a function is a segment of code that is isolated from the main code segment. A function is ''called'' from a section of code. When the function's code has been executed, it ''returns'' to the calling code. The general form of a function is:

	:{\|		:{\|