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.
Etude de cas : surcharge d'opérateur et première version
Loading...
Do curso por École Polytechnique Fédérale de Lausanne
Introduction à la programmation orientée objet (en C++)
180 classificações
École Polytechnique Fédérale de Lausanne
180 classificações
Na lição
Etude de cas
Nous terminons notre cours par une étude de cas détaillée qui met en lumière les différents concepts rencontrés.
Conheça os instrutores
Jamila SamDr
School of Computer and Communication Sciences
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
In the previous episodes,
we presented the general problem of the case study
we are now working on,
which is to model watches with different mechanisms
and different accessories.
Then, we covered the more specific problem
of overloading the output operator
and how to handle polymorphic output.
We also completed the "Produit" class.
In this video, we will focus on
overloading another operator, for example the "+=" operator.
Then, we will build a first, real
operational version of the program.
Let's start by adding the "+=" operator
to the "Montre" class (TN: "montre"means "watch"),
which, remember, inherits from "Produit"
and has a mechanism, more specifically a pointer
to a mechanism, for polymorphism,
and a dynamic array of pointers to accessories
which we have called "accessoires" here.
The idea is to be able to add elements to this dynamic array
by doing, for example for "montre", an instance of the "Montre" class,
" montre += new Bracelet (...); ",
where, as you will recall, "Bracelet" is a subclass of "Accessoire".
So we would like this to add a new pointer to a "Bracelet"
into the collection of pointers to "Accessoires".
Since a "Bracelet" is an "Accessoire",
a pointer to a "Bracelet" can be put into a pointer to an "Accessoire".
That's the idea for this "+=" operator.
The prototype of this operator will look like this:
we won't use its return value,
as we will never write things like
" z = (montre += new "Bracelet" (...)); ".
So here, we have a "void" return type.
This is the "+=" operator for the "Montre" class
and the operator must take
a pointer to an "Accessoire",
so here, "new" will return a C-style pointer,
and we want to view it as a pointer to an "Accessoire".
So here, in a very general way, it will be a pointer to an "Accessoire".
Here, we added a bracelet, but we could add a clasp,
a body, or any other subclass of "Accessoire".
Now, let's see how we can write its definition.
This pointer to an "Accessoire", "p_accessoire", that we received,
we simply want to add it to the dynamic array of accessories
stored in the watch.
So we will simply call "push_back" with this pointer,
but here, since we received a C-style pointer,
we will transform this C-style pointer
to a "unique_ptr".
So here, we create a "unique_ptr" which converts this C-style pointer,
"p_accessoire",
and we add it to the end, we "push_back" on the "accessoires" vector,
in which all the accessories of the watch are stored.
That's it for this very simple overload
of the "+=" operator, which now provides us with
a very compact syntax to add accessories to a watch.
Now, let's try to write a first operational
version of the program.
Let's try to finalize what we have written up till now;
and for now, let's not add any mechanism
or copy any watches.
We will leave these two aspects for the next two episodes.
To be able to finalize the program as we have written it up till now,
we would need a few more concrete accessories
and we would have to finish the "Montre" class
which is yet not quite operational.
And of course, we must use all this in a typical "main".
We will go over all of these points one after the other,
starting with a few more accessories.
Remember that we have an "Accessoire" class, which is a product,
and let's say for example that accessories need
a name to describe them.
To do so, let's say we have a name that will not change
once it has been set by the constructor.
And we will add a constructor to the "Accessoire" class
which will take a name to refer to the accessory.
And let's not forget that any product can be sold and thus has a price,
and so it will take a second parameter
to initialize the price of the product.
The initialization list in the constructor for "Accessoire"
will start by calling the constructor for the "Produit" superclass
passing it the second parameter we received for the base value.
Then, we will initialize the "nom" member (TN: means "name") with the name we received.
That's it for the constructor we decided to give to all the accessories.
Now, let's decide on a way of displaying the accessories
since, remember, all products can be displayed
in a polymorphic way.
So we will overload the "afficher" method
that was inherited from "Produit".
We override it by adding the "override" keyword.
And let's say that the output will be their name and price.
So we will simply display the name,
then indicate how much it costs.
And we already know how to display the price by directly calling
the afficher method from the "Produit" superclass.
Here, we use the scope resolution operator
to access the afficher method inherited from the "Produit" superclass.
Because of course, if we simply write "afficher" without this,
we will call the "afficher" method from the current class
and we would have infinite recursion here, where "afficher" would call itself.
And so, in the "afficher" method of the "Accessoire" class,
to call the "afficher" method inherited from the "Produit" superclass,
we need to unhide this "afficher" method.
Next, since we expect a polymorphic behavior
with virtual methods,
we don't forget to add the polymorphic destructor,
the virtual destructor,
in the class for which we want polymorphic behavior.
This way, if subclasses inherit from it,
as will be the case with accessories,
which need to have destructors with specific behaviors,
then their own destructor will indeed be called in a polymorphic way
-- and not the destructor for the "Accessoire" class.
Finally, let's say that the price of accessories
is the same price as a normal product,
that is, a very general product as we had designed it
right at the top of the hierarchy.
At that point, we don't have anything to do
since the "prix" method that we inherited
from the "Produit" class is enough here
and we don't need to override it in the "Accessoire" class.
So here, we have completely functional
"Accessoire" class which corresponds to what we wanted.
Now, let's define a few accessories,
for example a "Bracelet". A "Bracelet" is an "Accessoire",
so here, we will have an inheritance link.
At the accessory level, let's say that their name
-- remember that accessories have a name, so
all accessories will inherit this name --
let's say that we want each accessory
to have a name that marks what they are.
For example, the name of a "Bracelet" will start with "bracelet"
the name of a clasp will start with "fermoir" (TN: means "clasp").
We will force this in the constructor.
For example, for the "Bracelet" subclass of the "Accessoire" class,
we will take a name, which will be the complement that we add after "bracelet",
for example "en cuir" (TN: means "made of leather")
so that the complete name becomes "bracelet en cuir" (TN: "leather strap").
And as a second parameter, the price,
which we also pass to the superclass's constructor
in the initialization list.
And all of these classes can potentially have
polymorphic subclasses,
so let's not forget the virtual destructor.
Similarly, we could define a "Fermoir" class (TN: means "Clasp") inheriting from "Accessoire"
in which we define a constructor
taking a complement to the "fermoir" name and a price,
to be able to call the constructor of the "Accessoire" superclass.
The complete name will thus be "fermoir" with this complement
that we received as the first parameter,
and as the second parameter, the price that we received,
and as always, a virtual destructor.
There, we have finished with the accessories.
Now let's try to also make the "Montre" class usable
without mechanisms and without copying
which we will leave to the side for now.
At this stage, we have completely defined the contents of the "Montre" class,
we have prevented copying,
and we have added the "+=" operator
allowing us to add accessories to our watches.
To make this class operational, we must add at least one constructor
since we have modified the constructor here,
the default constructor, provided by default, is no longer so.
We don't have the default constructor anymore,
so we must at least add it here.
Of course, the default constructor will do nothing
to initialize the mechanisms,
and so at this point we will simply comment this out,
to avoid any problem with using a pointer
that would not be initialized --
we will simply comment out this line.
Regarding the vector of pointers to accessories,
the default constructor
will create an empty vector
and so here, there is no problem.
We will be able to fill this vector using our "+=" operator.
So the default constructor suits us, as long as we
don't have this pointer
so we will comment it out for now
and come back to it in a subsequent episode.
That's it for creating watches.
Now, let's decide how to compute the price of watches,
and let's say that it is the sum of the prices of its accessories.
For that, we will override the "prix" method,
we override this "virtual prix" method
inherited from the "Produit" superclass.
We will decide that at first, the price of a watch is its base value,
that we fetch through the original "prix" method,
inherited from the "Produit" superclass.
Then we will add, to this base value,
the sum of prices of the different accessories.
To do so, we go through the list of accessories
-- remember that to iterate over an array of "unique_ptr"s,
it is crucial to use this syntax, to use references -
here, fetching the price will not modify the instances we iterate over,
so we will use a constant reference
Here, we will write a loop that iterates with a constant reference
over the "unique_ptr"s of this dynamic array of accessories.
And we add to the price, that we had originally initialized,
the price each time, that is, the result of the call to the "prix" method
of the object pointed to by "p_acc" here,
so the object pointed to via this pointer.
This is how we write the call to the "prix" method
for something that is a pointer to an object
providing such a method.
And finally, we return the price that we have just computed.
Finally, let's decide how we want to display the watches,
and let's say for example that we want a message to say
that a watch is made of: the list of its various accessories, ...
And at the end, we display the total price of the watch.
And so here, we will also override the virtual "afficher" method
inherited from the "Produit" superclass.
And remember that here we are overriding it,
starting by displaying: "A watch is composed of",
then by iterating over the vector of accessories of the watch,
and for each accessory, we display this little star
then we display the current accessory.
Question here:
are we allowed to write this?
Will this compile?
Have we overloaded the output operator for this?
Yes, it is correct and it compiles.
And finally, we end by displaying the message "total price"
and calling the watch's "prix" method,
which will compute the total price, as we have just seen.
Finally, to have an executable program,
we need a "main", which we will use here to test
the implementation of the objects we have just created.
For this, we will declare a "Montre" in the "main".
We can easily do this
since we have a default constructor now.
Then, we add various accessories to the watch, like so.
Each of the accessories has a constructor with its name or the complement to the name,
and its price
So here, we add for example 4 accessories,
and finally we output a message to display the watch here,
with the output operator we saw earlier.
This output operator, as we have just discussed,
will call the "prix" method.
The execution of this program will thus yield the following result:
first, we will display the message "Montre m : ",
then we will enter the overload of the operator for "Produit",
but with a call to the polymorphic afficher method
for "Montre",
which will thus display: "Une montre composée de: "
then a loop over its various acessories,
and finally will display the total price,
the sum of prices of its accessories.
For those who would like it,
all of the code is available on the course website
This concludes the presentation of this first operational
version of our code.
There are still two chapters to cover in the next two episodes:
first, all of these mechanisms, with multiple inheritance,
and then the concept of copying a watch,
how to make a deep copy of the various "Accessoires" of a "Montre".
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2018 Coursera Inc. Todos os direitos reservados.
