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.
Puissance 4 : premières fonctions
Loading...
Del curso dictado por École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en C++)
197 calificaciones
De la lección
Etude de cas
Nous voulons terminer notre cours avec une étude de cas, la création d'un jeu de « Puissance 4 », nous permettant de revoir tous les concepts abordés au long du cours. Nous en profitons pour présenter un dernier type de données : le type « énuméré ».
Conoce a los instructores
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
The coding of an application, whatever it is,
requires a careful thinking of the involved data
and of the fundamental functionalities
which will enable to implement the desired processing.
In the previous episode., we have already started this thinking
about the coding of the Connect Four game.
This has lead us to identify the fundamental types
in order to represent the game grid.
Today we will expand our reasoning
and focus on the basic funtionalities.
Little reminder: in the previous episode,
we have paid attention to the types of the involved data.
Very naturally, we have contemplated the modelling of the game grid.
Thus, we have introduced the new type "Grille" (TN: means "grid")
as a two-dimensional array.
We have also modeled the cells' content
of all the array's elements.
This has lead us to introduce a new enumerated type,
the type "Couleur" enabling us to represent
the content of each array cells.
The grid's size being fixed, we have naturally chosen
to use the "array" type, introduced in C++2011, letting us
represent a fixed-size array.
We have simply declared the type "Grille" as
representing a two-dimensional array,
its size being fixed with 6 rows and 7 columns.
Each element of the grid is of the type "Couleur".
"Couleur" being an enumerated type allowing only the values "vide" ("empty"), "rouge" ("red") and "jaune" ("yellow").
Once these types have been introduced, we can easily, in our program,
declare a Grille-type variable and assign values
to its different elements.
These values will be taken among the ones of the enumerated type,
that is, "vide", "rouge" or "jaune".
The fundamental types having been defined,
we will now focus on the first functionalities
we will operate on our grid.
At the beginning of the game, we will probably want to start
playing with an empty grid.
Therefore, we will have to focus on the initialization, letting us initialize
each of the array cells to the value "vide".
Also, we will have to allow the printing of the grid,
so that players may have an understanding of their advancement in the game.
In the this episode,
we will focus on implementing concretely these two functionalities.
We will forsee the coding of a function "initialise" (TN: means "initialize)
initializing the grid
as well as the coding of another function called "affiche" (TN: means "print")
which will print the grid.
Let us begin with the initialization.
Let us imagine how to concretely use
this "initialise" function in a program.
We can imagine that, in a program, we have previously declared
a Grille-type variable "grille". In order to initialize this grid,
we can imagine to write a function
which can be called like this.
We will call the function "intialise" taking, as paramter, the grid
in order to modify its content.
How will be modify its content?
Well, simply we will fill each of its cells with the value "vide".
Now, let us focus on the coding of the "initialise" function.
We can see that the function "initialise", the way we see it,
does not need to return any result.
Its purpose is to modify the grid, to initialize it.
Naturally, we will describe an "initialise" function whose
return type is "void", for we do not need
to retrieve a value after the execution
of the "initialise" function.
We will write the "initialise" function passing a Grille-type parameter.
The "initialise" function will have to modify the grid.
Therefore, once we have finished executing the function,
at this point of the program,
we will retrieve a grid, the contet of which has been modified.
For this reason, we will have to resort
to passing by reference
so that the grid will indeed be modified by the initialization function.
By the way, please note that this way to code the "initialise" function
is obviously not the only possible solution.
We could imagine that, instead of working directly on
the provided grid, the "initialise" function
could return a
correctly initialized grid.
This would correspond to the following call.
Here, we would replace the two lines of code we have written here
by something like this.
We could call the "initialise" function which,
instead of modifiying a provided grid, would return a new grid.
At this point, the return type would no longer be "void"
but "Grille" instead.
Also, any parameter would no longer be necessary
since the "initialise" function would return a grid.
This is another way to proceed, a way we have already discussed
in the course about "structures",
with the example of the function enabling
to "give birth to a new person".
In this episone, we have chosen an alternative conception,
especially illustrating the idea of by-reference passing.
The header of the function is now clearly defined
and we can move on to developping its body.
Let us focus on the content of the function body.
What this function has to do is, for each row of the array,
to iterate on each cell and assigning it the value "vide".
Let's see how we can proceed
to initialize a single row.
Let us imagine we are trying to do so for the first row of the grid.
Obviously, we will need to write a "for loop".
This loop will iterate on each element of the row.
We can imagine a range-based for-loop
which is written like this.
As a first introduction. we will first do so for the first row of the grid,
iterating square by square.
This is written like this.
We will fill the content, assigning the value "vide" to it.
At this point, as an exercise, we have written the lines of code
initializing the first row of the grid,
storing the value "vide" in each cell.
Here, we can simply close the function.
By the way, please note the use of a "reference" type
for the iteration variable in the range-based for-loop.
This is mandatory if we want the
content of each square to be modified.
If we compile the program as such,
we will however encounter a tiny problem.
The identifier "case" (TN: means "square"), although very natural in French in order to identify
a square of the array is actually a reserved keyword of the C++ language.
We are therefore not allowed to use it as a variable identifier.
Therefore, we will have to make a slight change
so that the program may effectively compile.
We will change the identifier name.
We way take the precaution to comment the reason behind this choice,
explaining that we are not allowed to use the reserved keyword "case"
since it is a reserved keyword of the language.
Obviously, we will have to rectify the identifier wherever it is used.
Like this.
Obviously, this processing we have implemented to initialize
the first row of the grid must be repeated for each row
so that we can initialize the whole grid.
It is natural to imagine imbricating these processing
in a first "for loop"
which will be tasked to iterate on all the rows
and realize exactly the same processing.
Let 's write this first "for loop"
iterating on all the rows of the grid.
Once again, we can use a range-based for-loop.
Therefore using a variable "ligne" (TN: means "row") iterating
on each row of the grid.
For each row, we will have to replace "grille[0]" by "grille[ligne]".
We are realizing the same processing as before,
thus storing the value "vide" inside each square.
We correct here our identation.
Finally we have all these lines of code,
enabling us to iterate on all the rows
in order to modify their content.
By the way, please note the passing by reference
for the range-based for-loop variable, so that
the grid will indeed be modified.
We are now able to initialize a previously declared grid
thanks to the Grille-type defined during the previous step.
Let us now focus on the printing of the grid.
As before, let us imagine the concrete utiliization
of this printing function.
It is always recommended to start off by imagining how the function
will be used before its effective coding.
Typically, we can imagine that, once the grid has been initialized,
and other processing done on the grid,
we will need to print it.
It is natural to imagine calling an "affiche" function (TN: "affiche" means "display"/"print")
taking, as parameter, the grid "affiche".
Let us now focus on the prototype.
As before, the type "void" is natural since the printing function
will simply print the grid on the terminal
and does not need to return any result.
Here, we pass the grid as parameter.
Now we are wondering :
Under what form should we pass the parameter "grille"?
Should we resort to passing by value or by reference?
The printing function's purpose is to print the values
of the different squares of the came grid.
Its goal is therefore not to modify the content of the grid.
Therefore, it rather natural to imagine
to resort to passing by value for the parameter "grille".
Indeed, it is not necessary
for the printing function to modify the grid's content.
However we have seen that, when passing by value, a copy
of the argument passed to the function is made
in an area local to the "affiche" function.
If the object passed as argument is big,
this copy can be quite resource consuming.
At this point, we therefore resort to an alternative,
an optimization consisting of passing the parameter by reference.
This will let the "affiche" function work directly
on the memory area corresponding to the passed argument,
without any copy.
However, we take the precaution to pass the argument by constant reference
in order to make sure that the "affiche" function,
even if it operates directly on the argument,
will not modify its content.
For example if, within the body of the "affiche" function,
we attempt to modify the grid's content,
it will result in an error upon the compiling.
By the way, please note that we could very well have written this:
This notation is perfectly equivalent to the former.
We can use both notations indefferently.
This here is an optimization letting the function
work directly on the argument but
adding in stead certain railings
hindering the function to modify the grid's content,
for this is not the purpose of the function.
This precautation was essential in C++98.
In C++2011 however, it is not always the case.
However, these practice considerations stretch beyond the range of this course.
We will simply settle for implementing this precautation:
good practice in order to avoid the unnecessary copy.
Here, the prototype of the "affiche" function will use the
passing by constant reference in order to avoid the copy.
Let's now proceed to code the body of the "affiche" function.
Here, the coding is rather natural.
It is rather similar to what we have done for the "initialise" function.
The goal will be to iterate on each of the grid's rows.
Then, for each of the grid's row, we will iterate on each square
in order to print its content in a particular format.
Here, we will not do any graphical display
but will simply print the content of each cell
on the terminal, following a particular convention.
In order to iterate on all the grid's rows,
a range-based for-loop is rather natural.
We know exactly how many rows and how many columns there are in the grid.
So here, for each of the grid's rows;
this is written like this, with a range-based for-loop;
we will iterate on each square of the considered row.
We will thus print the content of each square,
in a particular format.
We will have to resort to tests in order to know, depending on the content,
what is to be printed.
For example, if the square contains the value "vide",
that is, if the value of the enumerated type "Couleur", is "vide",
we can choose, by convention, to print a blank space on the terminal.
Otherwise, we will resort to other tests.
If the value of the square corresponds to the value "rouge" of the enumerated type,
second possible convention, we can choose any convention,
here, for example, an 'O' for the value "rouge".
Otherwise, last possible case, we know that it contains the value "jaune".
We make a printing choice: for example, an 'X'
signifying the value "jaune".
Here, we conclude the body of the first "for loop",
the inside "for loop".
At this point, we have printed the content of one row.
We take the precaution to generate a line break,
separating the different rows,
once a row has been printed entierely.
This closes the body of the very first "for loop".
Then, we will end the body of our "affiche" function.
You will note here, that it has not been necessary
in our range-based for-loop
to resort to the ampersand symbol ('&').
Why is that?
Because we are only consulting the content of the different elements.
We do not aim to modify their content.
In this case "auto", withtout the by-reference symbol ('&')
is amply sufficient.
As good programmers, we will now
comment the "affiche" function.
Indeed the printing choices we have resorted to
are not necessarily forseeable.
It is therefore useful for someone consulting our code
to know the used conventions without having
to read the whole function body.
At this point, we take the precaution to comment our code,
explaining the conventions adopted for the coding.
We precise that we will print an "O" for a red square and "X" for a yellow one.
Testing the functionalities as we progress
in the coding of an application is absolutely indispensable
in order to produce a sturdy and high-quality code.
This recommandation has been given
at the very beginning of our case study regarding the Connect Four.
We will thus begin testing our first functionalities,
namely the grid initialization and its printing.
In order to test the aforementioned functionalities,
we simply need to write a little main program,
calling the functions "initialise" and "affiche" on a previously
declared grid.
Here, we call the initialization and printing
functionalities on our grid.
It could be natural to wish to test the printings
of all the possible forms.
If we simply initialize the grid and print it directly,
all the squares will be empty.
At this point, it is interesting to make sure that all the cases are correclty covered.
We will try to cover all cases by filling the grid,
at certain places with yellow disks,
at others with red disks.
We are doing just that here, on randomly chosen squares.
The expected printing, following the program execution
should look like this.
Here, for every square of the grid,
excepted the ones we have explicitly assigned,
we should print a blank space.
We are representing this here with this symbol for more clarity.
However, please note that, in reality, only a blank space will be printed.
And, for the two particular squares we have filled
with red and yellow disks, we will have particular printings.
Here, the square on the 2nd row, 3rd column must be yellow;
this corresponds, according to our printing convention to an "X".
Here, we indeed have the row index 0, 1, 2.
This corresponds to this row number.
The column index 0, 1, 2, 3, which corresponds to this.
Similarly we should have the printing convention
of a red disk on the 2nd row, 4th column.
Concretely, in our Connect Four game, this playtest allows
to create a grid with a yellow disk here and a red disk here.
The bases have now been set and we can start
to focus on more cosmetic aspects,
tweaking aspects.
Here, the printing of the grid is rather dry.
It is not easy to distinguish columns,
Also, the separation between blank spaces is somewhat hazy.
Therefore, it would be nice to improve this printing;
this can be done by completing the existing code,
adding the following aspects which we will now comment.
This should provide a more explicit printing.
Especially separating the different columns with vertical bars
and explicitly numbering the different columns
below the grid in order to make it easier to visualize
the content of our game grid.
What were the necessary additions leading to this printing?
Well, we begin, before each row,
to print a blank space followed by a vertical bar.
This will allow to print each of these elements for each row.
Then, following the printing of each case's content,
be it "vide", "rouge" or "yellow"
we print a vertical bar just after this printing.
Therefore, we will print each of these vertical bars here.
The reamining processing is rigorously identical.
Then, once the whole grid has been printed,
we will focus on printing this part above the grid.
This is fulfilled by these lines of code here.
Let us comment them.
We begin by printing an equals symbol, this symbol.
This is a particular case,
not corresponding to the content of a column.
It simply corresponds to the blank space preceeding the first column.
Then, thanks to a "for loop",
we will iterate on all the rows in order to print their number.
We preceed the printing of each number with the equals symbol.
Actually, this "for loop" here will let us print
each number preceded by the equals sign.
Here, we took the precaution to number the columns
starting with 1, making it more readable.
Once this "for loop" has been executed, we will have printed
the last column number, preceeded by the equals symbol.
If we wish to close the printing harmoniously,
we still have to print this double equals symbol
which you can see here.
This is followed by as many line breaks as necessary.
At this point, we have tweaked our printing,
thus making it more readable.
Please note that we are not iterating
on all the grid's values.
We are iterating as many times as there are columns in the grid.
At this point, we are using a classical iteration
and not a range-based for-loop.
The "i"variable will take as many values as the number of columns in the grid.
The number of columns is a size-type element;
this is represented in C++ with the "size_t" type.
This is good practice
for the coding of such processing.
We have no reached the end of this step.
We have been able to model a Connect Four grid.
We also know how to initialize it and print its content.
We can now move on to the heart of matter
which will be the object of the following sequences.
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.
© 2018 Coursera Inc. Todos los derechos reservados.
