Ce cours introduit la programmation orientée objet (encapsulation, abstration, héritage, polymorphisme) en l'illustrant en langage C++. Il présuppose connues les bases de la programmation (variables, types, boucles, fonctions, ...). Il est conçu comme la suite du cours « Initiation à la programmation (en C++) ». Comme son prédécesseur, ce cours 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.
Encapsulation et abstraction : résumé
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Introduction à la programmation orientée objet (en C++)
181 notes
École Polytechnique Fédérale de Lausanne
181 notes
À partir de la leçon
Introduction à la Programmation Orientée Objet
Cette semaine vous accueille dans le cours et vous présente les premiers concepts de base de la programmation dite « orientée objet ».
Rencontrer les enseignants
Jamila SamDr
School of Computer and Communication Sciences
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
In the last episode, you learned how to write a class in C++.
Now you know how define member variables (data members) and methods,
and you know how to implement different
aspects of encapsulation,
such as define what is publicly accessible
for an outside user of the class,
and what is inaccessible.
In this lesson, we will examine several examples
to firmly establish these notions.
We will also see that good encapsulation
requires implementing a certain number of measures.
As a reminder, at this stage, a class is a more "elaborate" structure,
in which you can not only define certain properties or fields,
called member variables,
but also functions, that are called methods.
We saw that a class also distinguishes itself from a structure
by the fact that it can delimit what is private and inaccessible
to the outside world, and what is on the contrary
accessible, that is to say public.
Here is the definition of our favorite class Rectangle,
that served as an introductive illustration to the fundamental concepts
of OOP.
To define a class, we use the special keyword "class",
followed by the name that we chose for our class.
Because this name will be a type in this program,
it has to be capitalized.
A class is usually caracterised by a certain number
of data fields that are also called "data members".
Here we logically chose to characterize the class Rectangle
by the variables height and width, (TN: "hauteur" means "height", and "largeur", "width"),
that we chose to define
as two doubles.
A class is also characterized by a certain number
of specific functionalities called methods.
So once we have defined these basic elements,
the data members and methods, we can now examine which
elements are part of the internal implementation
and does not need to be known outside the class,
and those that constitute the user interface, which the outside world
needs to know and to use
in the class in question.
Here we have made available to the outside world as functionalities
5 methods that allow
the values of the data members width and height to be returned
and to be modified, and the surface area to be calculated with
the values of the width and height.
The components of the interface are specified
as being "public".
And conversely, the members named "private" are considered
as implementation details,
and this is usually the case for data members.
Note that it is normally not necessary
to systematically define get/set methods,
for each of the class data fields.
Here we defined them because at this stage of the course,
we only know how to interact with the contents of a class,
on a very basic level.
That is why we need setters
to set the appropriate values
of the data members width and height.
Respecting guidelines for encapsulation
by declaring private that which pertains to implementation,
typically the data members of a class,
will give the program designers of the class Rectangle
the freedom to modify its implementation
without effecting those who use the class.
For example, if the programmer
decides to modify the class's implementation
by using an array of 2 elements
instead of 2 doubles here, like this,
he only needs to internally adapt the implementation of these methods,
for instance here, instead of returning "hauteur" the height,
he returns "dims[0]".
So he only needs to adapt the implementation of these methods,
for the code to still function
for the user without
any modifications being seen.
Note also that the external user of the class Rectangle,
can only access the data fields of the class
through a predetermined interface,
which allows how the data is accessed
to be closely regulated.
Do you know how to improve this code
for the class Rectangle
with regard to this point?
The code here
corresponds to the class written by the program designer
of the class Rectangle,
let's see what happens on the user's side.
The user can be the same person who coded the class Rectangle,
but not necessarily.
Here is a main program, that is client
of the class Rectangle, that was defined on the previous slides.
So the class Rectangle henceforth defines a new type that can be used
just like any other type
that we've used up to now.
We can declare a variable of type Rectangle,
that we usually call an object, or instance,
and start to work with it.
When this line has been executed,
we now have at disposal in the memory,
of an object, of type Rectangle, that has two data fields or data members,
one for the width and one for the height.
So the first rational thing to do,
is to initialize these two members,
so as to be able to work with a rectangle with real dimensions.
The initialization of an object, strictly speaking, is actually an entire topic
that we will soon examine in detail.
For the time being, let us be content with
assigning values to the selected data members.
So the assignment of the width and height,
can be done simply with input from the keyboard.
We will ask the user to introduce a value for the height,
a value for the width, that will be read into a variable "lu"
(TN: = "read")
declared beforehand, and that will be be set as value for
the data member width of the rectangle with the set method
that was written for this purpose.
So imagine here that the user introduces the value 5.0
into the variable "lu", and, using the method "setHauteur",
along with the dot notation,
which means set the height of rect at the value of "lu".
So we end up in this situation concretely.
The same applies for the width
like this.
Once the rectangle is properly initialized,
we can invoke other functionalities on this rectangle,
in this case, calculating its area,
and again we use dot notation
which means here that I calculate the area of the rectangle.
In conclusion here is a refined version of the class Rectangle,
based on the externalization of method definitions.
So here only the method prototypes are kept in the class rectangle,
while they are effectively defined outside the class Rectangle.
The link between the method and its class
is made by the scope resolution operator.
The scope resolution operator ( : : ) enables a local name,
for example the name of a method,
to be linked with a more global name: the name of the class
to which the method belongs.
The advantage of externalizing is namely that the class declaration is
not cluttered with details of method definitions.
What is constituted only of
method prototypes and data members,
is what is called a "class prototype".
And what is constituted of the method definitions
is called the "class definition".
So exactly like we saw for functions,
the prototype allows for agreement between
the program user and the program designer
of the class Rectangle.
The definitions are only known by the program designer.
The person who uses the class Rectangle
only needs know the public section of his prototype.
Note that in a judicious design, we will be careful to specify as const
the methods that are not mutators,
and do not modify the value of data members.
Several small details can be noticed here,
notably that certain programmers
find it useful to use particular
naming conventions especially for data members,
such as ending the name with an underscore.
This is to avoid any possible shadowing
with the names of parameters in methods.
You will also notice how the programmer
names the accessors and mutators here.
In the last version of this program,
the method that returned the height of the rectangle,
was called "getHauteur",
but that here it is simply called "hauteur".
The same for the width.
Likewise, the method that can modify the height of the rectangle
by setting a certain value,
was called "setHauteur", but now is called "hauteur".
Some programmers find this way of naming
accessors and mutators
more clear, more readable to use.
For example, here, if in a program that uses the class Rectangle,
I want to print the height of a rectangle,
that was declared beforehand,
I only need to write "rect.hauteur()".
And not "rect.getHauteur()",
which is a bit more bulky.
Likewise, if in a program I want to modify
the height of a rectangle,
I can simply write: "rect.hauteur(30)"
which is considered less cumbersome
by some programmers.
Here we are employing the overloading principle:
giving two different methods the same name.
The same conditions apply for
the methods of a class,
as for normal functions.
So there can be no amibguity concerning which method is called.
The method "hauteur" here is a mutator that is distinguished
from the method "hauteur" that is an accessor
by its list of arguments, which differ from each other,
but also by the presence or absence of the keyword const.
So no confusion is possible here.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2018 Coursera Inc. Tous droits réservés.
