Ce cours initie aux bases de la programmation en utilisant le langage C++ : variables, boucles, fonctions, ... Il ne présuppose pas de connaissance préalable. Les aspects plus avancés (programmation orientée objet) sont donnés dans un cours suivant, «Introduction à la programmation orientée objet (en C++)». Il s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Fonctions : définitions
Loading...
Del curso dictado por École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en C++)
243 calificaciones
De la lección
Fonctions
Cette semaine aborde un sujet fondamental en programmation : les « fonctions » qui permettent de beaucoup mieux structurer les programmes et d'éviter d'avoir à récrire plusieurs fois la même portion de code.
Conoce a los instructores
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
In the previous episodes,
we went over the three aspects of functions.
We've seen what a function call is,
and we have also seen, in another episode,
what a function prototype is.
In this episode,
we will focus on the definition.
If I come back to the example of the mean calculation,
the definition of the "moyenne" function are these lines here, at the bottom of the program. ["moyenne" means "mean"]
We will now focus specifically on this.
The definition of a function, as its name implies,
serves to define a function technically,
that is, to specify the body of the function,
the set of instructions
that make up this function.
Specifically, the definition of a function will start with
the header of the function,
that is, the beginning of the prototype, without the semicolon
where, as you already know, we first define the type,
then the name of the function and finally, between parentheses,
the set of parameters that we wish to pass to the function.
This header is followed, for the definition, by the block
which is the body of the function.
This body is a set of usual C++ instructions
which we put into a block here
and which contains one or more return statements
which will end the execution of the function body.
If I take, as an example, the "moyenne" ("mean") function,
we can see here the function header with the double return type, meaning
the function will return a double; its name and a list of two parameters.
Here, we will calculate the mean of two numbers x and y.
In the definition, we have the body of the function which is this block,
which is, here, simply one single return instruction and nothing else.
The body of the function is simply a block in the C++ sense,
that is, a set of C++ instructions contained between an opening brace
and a closing brace.
The only difference is that in this block, we have access to extra variables
which are the parameters of the function. We can use these in this block
as if they were any normal variable.
The value returned by the function is indicated by the <i>return</i> instruction.
This instruction is followed by an expression in the C++ sense,
which will be evaluated and will give the value which the function will return.
This expression must be of the same type as the function's return type.
In the mean calculation example, we have here the body of the function
which is this block here, which is very simple in this case,
as it contains only one <i>return</i> statement,
which will evaluate the expression here,
where you can see that we have
access to the two parameters x and y.
The expression will be evaluated, we will calculate <i>x + y</i>,
then we will divide by two,
and the result will be of type <i>double</i> and will be returned by the function
to the rest of the program. The <i>return</i> statement does two things:
it allows us to specify the type of the return value
which will be given by the function to the rest of the program
and it ends the execution of the function body.
As soon as the first <i>return</i> is encountered, the function halts
and returns the value corresponding to the expression.
Very often, you will find relatively simple return statement
which are just variable names,
such as <i>return x</i> where x is a variable name.
Or even values, such as return 3 to return a value of 3.
But this is a specific case,
and we can perfectly, as we have seen earlier,
use a complete C++ expression.
And this is the general case: the evaluation of a complete expression.
<i>x</i> and <i>3</i>, here, are simply particular expressions.
A few remarks about the <i>return</i> statement
on which it is important to insist.
First, we can place several <i>return</i> statements
in one function.
Let's look at a simple example of a function which will return
the biggest of two values, let's say, <i>a</i> and <i>b</i>.
I call my function <i>max2</i> simply because there already exists a function
named <i>max</i> in the C++ standard library.
Let's look at the body of this function. We start by declaring a variable <i>m</i>
and then, if <i>a</i> is bigger than <i>b</i>, then we copy <i>a</i> into <i>m</i>
and if <i>b</i> is smaller than, or equal to <i>a</i>,
then the value of <i>m</i> will be the value of <i>b</i>.
Then, we return the value of <i>m</i>.
However, we could have written this code with two <i>return</i> statements,
in a somewhat more compact way. The prototype remains the same,
but here, if <i>a</i> is bigger than <i>b</i>, we <i>return</i> <i>a</i>, which means
that if <i>a</i> is bigger than <i>b</i>,
we will evaluate this expression and return it, and we will stop here.
The <i>return</i> ensures that we stop here.
If, however, <i>b</i> is smaller than or equal to <i>a</i>,
then what will happen is that
this <i>if</i> instruction will directly jump here,
and now, it is this <i>return</i> which will be executed.
Please note that there is only one single <i>return</i>
executed for a given function call.
Second remark, the expression which follows a <i>return</i> instruction in a function
must of course be of the same type as the return type indicated
in the function header.
For example, here, if I have a function <i>f</i> which does not take any arguments
but which returns a <i>double</i>, then
all the <i>return</i> statements in this function must be of type <i>double</i>.
Here, I have an expression which returns <i>b</i>, of type <i>bool</i>. This is incorrect,
and it will generate an error.
Third remark concerning the <i>return</i> statement:
it must of course be the last instruction executed
since the <i>return</i> statement ends the execution of the function.
It makes no sense to put instructions after the <i>return</i> statement.
Let's take, for example, this <i>lire</i> function ["lire" means "read"], which must return
a double after reading it from the standard input.
It begins by displaying a message on the standard output
and then. it declares a variable of type double called <i>n</i> and initializes it
with a value of 0. It reads the value of the double on the standard input
and finally, it returns to the rest of the program the value of <i>n</i>.
After this, the <i>lire</i> function ends.
So there is absolutely no reason to put an instruction after this,
it would be completely wrong.
Fourth and last remark concerning the return statement.
The compiler must always be able to execute a return statement.
Here is the example of the <i>lire</i> function again, written
slightly differently.
We see, again, the request for the user to input a number,
the declaration and initialization of the variable <i>n</i>,
the reading, from the keyboard, of the value of <i>n</i>;
but here, we have a simple test to check if <i>n</i> is strictly positive.
If so, the function will execute the return statement and will thus end
and return the value of <i>n</i>.
But what happens if <i>n</i> is negative?
It is quite possible for <i>n</i> to be negative,
we can absolutely assume that at this point,
the user might have entered a negative value.
In such a case, this test here will be false and so the function will jump to the line after
the <i>if</i> statement and will end up here. And you can see that from
here, there is nothing left to execute. The function will thus end <i>without a return</i>
value. This is impossible,
so the compiler will throw you an error.
The compiler verifies that the function will always end
with a <i>return</i> statement,
which returns a double, here, since it is the function's return type.
In this particular case, what we could have done
would have been to correct the function by adding, for example, a loop here
that would go back to the top of this block as long as, e.g.,
the value of n is negative or zero. Then we would repeat the block
that asks the user for number and assigns it,
which would allow the function to end with a legal value every time.
More specifically,
since we first want to ask the user for a value before testing whether
it is positive or negative,
we obviously need a <i>do while</i> loop.
So, let's write the <i>do while</i> loop here,
with, as condition,
that we ask the question again as long as we get a bad answer.
Originally, we wanted <i>n</i> to be positive
to have a good answer. So we will repeat the loop <i>while</i>,
as long as, <i>n</i> is negative. While it is negative, we must repeat
this loop and as soon as <i>n</i> will have a positive value ,
we will be able to return the value. So we can already write the <i>return</i> statement.
Then, in the loop, we will get the user's input --
first we ask them the question, and then we save their input.
This is what the loop will do.
We write the message here, and we read the value into the variable <i>n</i>.
Now, we still need to declare this variable <i>n</i>
since we use it here as a condition for the <i>while</i> statement
which is outside of the <i>do while</i> loop and since we also use it here for
the return statement; we will declare this variable outside of the block to be able to use it
outside of the block. So we will declare it here, and initialize it with a value
that makes sense, for example, 0.
So, here is the precise form, which corrects the previous mistake.
Now, let's go over a few special cases of functions.
Let's start, for example, with a function
which has no return type.
I must remind you that a function in programming has nothing to do with
a mathematical function.
In programming, a function is simply a set of instructions
that we have put to the side, and named.
This set of instructions
can certainly have no return value.
It will return nothing to the rest of the program.
Such a function is sometimes called
a "void function". [In French, there is a special word for it: "procedure", not used in English]
Such a function will need a specific kind of declaration.
The declaration of its type, since it returns nothing,
will be done with the reserved word <i>void</i> to indicate
that it has no return value.
If I take the example here, at the bottom of the slide,
the function "affiche racine" [means "display square root"] will simply
print something to the terminal and has no need for a return type,
since it does not need to return anything to the rest of the program.
We will, if you will, "define its return type", indicate the fact that
it does not return anything, by using the reserved word <i>void</i>.
Since such a function does not return anything to the rest of the program,
it needs no return instruction,
and the return statement is optional in these functions.
However, it could be useful to halt the execution of the function
prematurely, for example, depending on the result of an <i>if</i> statement.
Here, we can certainly put a <i>return</i> statement in the function body --
and this <i>return</i> will be followed by a semicolon.
If I go back to the "affiche racine" function here at the bottom of the slide,
which returns nothing at all,
since it simply displays on the screen
the square root of the argument received.
If "a" is negative here, then we should simply display nothing,
since the square root of a negative number is not defined.
So here, we will
halt the execution of the function body
with a return statement
which returns no expression,
which is followed by nothing.
If "a", for example, is positive, then the <i>if</i> will not be executed
and the function body will continue
normally by displaying its square root.
Another special case of functions: functions with no parameters.
We can of course define functions
which need no external parameter to work,
to do their job.
We have already seen this during the lecture on prototypes:
all we have to do is give an empty list of parameters,
which is simply a pair of empty parentheses, like this: <i>()</i>.
For example, if I want a "saisie" function ["saisie" means "input"]
whose job is to ask the user for a <i>double</i>
in the terminal. This function must return a <i>double</i>
but needs no parameter.
So we will declare a variable here, for example, a number of points,
that the user will input, which we will define with type <i>double</i>.
Here, the type we will use is the same as the type of the return value
since it is this variable that we will use
to return the value to the rest of the program.
We declare this variable here, "nb_points" ["number of points"] and initialize it to zero.
Then, we ask the user to input a number of points.
We will read the number of points
as supplied by the user.
And as long as the number of points
is negative or larger than a certain threshold,
we will loop and ask the user for input again.
When we finally have a correct value,
we return the number of points supplied by the user
to the rest of the program.
As you can see, the program which will use, which will call "saisie" [means "input"]
does not need to pass any arguments to that function.
The "saisie" function works completely autonomously.
Last special case of functions:
the <i>main</i> function.
"Main" is a function like almost any other.
It is simply the function which is called right at the beginning of the program.
This function has a special prototype. Actually, it has two,
but the prototype that we will use in this course is this one:
it must return an integer, <i>int</i>, and receive no argument.
The standard way of defining <i>main</i> is like this:
This integer, <i>int</i>, here, which we return to the rest of the program,
is what we return to the program which called our program, that is,
the environment
in which you will execute your program.
And this return value will typically be an error code. By convention, the value 0
indicates that the program was executed correctly.
It means that there was no error. It might be a little surprising,
but it is a common convention. Zero means that there is no error.
Generally, we use error codes bigger than zero, one, two etc.
to indicate that there is an error. But that is outside the scope of this lecture.
I will just mention the other prototype,
the only other prototype accepted for "main",
which we sometimes encounter.
In some development environments.
it is the one you will get by default.
It is a prototype which takes two arguments.
But it would take us a bit too far
to explain what these two arguments are now.
In short, they are parameters that we could receive
from the environment in which we execute our program.
Explora nuestro catálogo
Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.
Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.
© 2019 Coursera Inc. Todos los derechos reservados.
