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.
Surcharge d'opérateurs : introduction
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Introduction à la programmation orientée objet (en C++)
180 notes
École Polytechnique Fédérale de Lausanne
180 notes
À partir de la leçon
Surcharge des opérateurs
Cette semaine nous étudions comment étendre les opérateurs du langage C++ à nos propres classes.
Rencontrer les enseignants
Jamila SamDr
School of Computer and Communication Sciences
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
In this episode, as well as the upcoming ones,
we will focus on operator overloading.
This is a rather technical subject
which will make us able to define our very own operators.
Let us begin with an example so that we may see what purpose it serves.
For example, let us say we have defined a "Complexe" (= "Complex") class
in order to add complex numbers.
It does not matter what it is exactly.
What matters, is that we wish to add
complex numbers.
Let us suppose we have already defined a few complex numbers :
z1, z2 and so on.
How should we proceed in order to add these complex numbers?
For example, we may wish to store inside z3, the result of " z1 + z2 ".
Of course, we would very much like to write something like :
" z3 = z1 + z2 "
If we write this in our usual classes
we will get a compiling error
since the " + " is indeed not defined for z1, z2,
it is not defined for complex numbers.
Until now, we would rather
have defined a function in charge of the addition.
For example, we could define a function called "add"
which would work like this :
add(z1, z2) and " z3 = add(z1, z2) "
in order to store the result of the addition of z1 and z2 into z3.
And if we wanted to store, into z4, the result of the addition of
z1, z2 and z3, we would have to write it like this.
As the first argument, here, we add up z1 and z2
and then, as the second argument, we will call the function "add" again
and add z3 here.
Unfortunatley, this way to write it is rather unnatural.
It would be much more pleasant to write " z4 = z1 + z2 + z3 ";
it is much clearer than something like this with an "add" function.
Indeed, the goal of operator overloading
is to let us write something like this, using the " + " operator
with a class belonging to us, that we have defined,
called the "Complexe" class.
Similarly, we could wish to print
complex numbers in an homogenous way like this.
For example, printing the message " z3 = "
followed by the value of the complex number z3 so that we may print z3.
Why, writing this is only possible
if we do not overload the printing operator.
We daresay it is better to write this rather than having to cut out here
a printing of the message "z3 = " and then calling a printing function
which we have defined for the complex class.
Finally printing the line break like this.
This here is the purpose of operator overloading.
This will let us expand the use of the usual operators
(the ones we deem most useful)
to the classes where we wish
to add these different operators (addition, printing, multiplication)
according to our needs.
That said, operator overloading is still quite a technical subject;
it can be rather complicated since we are in the core of the language.
We will redefine elementary operations :
the operators.
Therefore, according to your level
or to the restrains you find yourselves in,
you have several ways to tackle the operator overloading.
You can decide not to use them at all and continue
using functions as you were doing up until now.
Also, you may decide to introduce only the operators
relatively simple : additions, multiplications
without worrying about the so-called auto-assignment
(that is, += , -=, x= ).
At this level, you may also decide to overload the printing operator
if you find it useful.
At a higher level, you may start to tackle
the overloading of auto-assignment operators : += , -= and so on
but in a slightly simplified version
with the return type "void".
We will go back to this in detail in the different following episodes.
Here, we are giving the plan of the videos we will be proposing.
Finally, at the highest level, you may also redefine
these operators according to the standard, at a much higher level.
The level targeted by this course is the level 2.
We will thus do a relatively simple operator overloading.
However, in the upcoming videos, we will still present
the level 3 and the level 4 so that you know they exist.
If you interested, you may freely expand on the subject.
Now, let us dive into the heart of the matter :
this famous operator overloading.
First of all, what is an operator? Operators are signs used
to represent the operations
such as arithmetic operators.
For example, when you write " z = a + b ",
you are using the addition operator.
You have logical operators. For example, if we write
" (a == b) and (x == y) " here, "and" is an operator.
You also have comparison operators. For example, if you write : " x <= y "
you are still using an operator.
You also have the auto-increment operators. For example, when we write " ++i "
in "for loops".
You also have the assignment operator of which we have not yet spoken,
but which is written here. If you have : " z = something ",
it is indeed an operator. This operator is overloadable aswell.
We will talk about it in the very last video.
What you need to know is that when you write an expression containing an operator
(the operator "==" here, the operator "and"...)
it corresponds to the call to a function
or to a call to a method (class member function).
Every time you write "a Op b ",
either you have the function "operatorOp (a, b) ".
For example, when we write " a + b ",
it means we have either a call to the function " Operator+ (a, b)
or (we will see the distrinctions later) the class method
of which a is an instance : a.operator+
This means the method "operator+ " where b is the argument.
Similarly, if we have unary operators
(operators with only one operand),
for example, when we write " -a " to take the opposite of a,
or when we write " ++a " to increment a,
it is either a call to a function or a call to a method. In the case of "-a",
it is either the function "operator-" with a as argument,
or the method of a class instance written " a.operator- "
here without argument.
Similarly, " ++a" will either call a function
according to what has been defined ( "operator++ (a))
or the method "operator++ " of the class where a is an instance (a.operator++()).
To give more examples, when you write "cout << a ",
you are either using the function "operator<< " taking cout and a as argument
or (since cout is an instance of class
called "iostream") the method "operator<< "
of the class where "cout" is an instance, that is, the "ostream" class
with a as parameter.
Finally, you need to know that when you call " a = b ",
you indeed in this case here.
However, there is no function " = " with two arguments.
Therefore, we are perforce using the method " operator= "
of the class where a is an instance called
with b as parameter.
Those were a handful of examples.
The set of the operators you can overload
is given as a pdf complement
on the course website.
This is it for the operators. Now what about the overloading?
The overloading is when a function or a method
has the same name as another function/method, both being distinguished by their arguments
For example, we can imagine a function "max" taking two integers as parameters
and another function "max" taking two doubles as parameters.
At this point, we say that the two "max" functions are overloaded.
There are several functions with the same name "max"
but distinguished by the types of their parameters.
Regarding operators, we will do the same thing :
we will overload operators.
For example, we will overload the operator " + " for the "Complexe" class.
Here, it takes two complex numbers and the addition of two complex numbers
returns here a complex number. For example, if we are working
with matrices we wish to add,
we may overload the operator " + " and take two matrices here.
This is the operator overloading.
It is the possibility to redefine operators having the same name :
"operator something" for different classes.
In C++, pretty much all operators are overloadable.
Once again, the complete list is given on the course website.
Therefore, you can freely overload the usual operators
for your classes. As we said, there are two ways
to interpret an operator : either as a function
or as a method.
Indeed, there are two types of overloading.
The so-called external overloading or internal overloading.
The external overloading is the one using usual non-member functions;
for example, "operator+ " taking two complex numbers
in order to do, for example "z3 = z1 + z2" which will be called "operator+ " :
" z3 = operator+(z1, z2) ".
This overloading is external to the class; we call it
an external overloading by opposition to the internal overloading
which is done inside the class and is the alternative.
This time, we would have " z3 = z1.operator+ (z2) "
where "operator+ " is a method of the class of z1.
Therefore, in an internal overloading, the operator corresponds
to a method (a class member function). On the other hand, in the external overloading,
the operator corresponds to a usual non-member function.
We will begin by presenting the external overloading.
Then, in the next episode, we will present the internal overloading
and decide which one is more appropriate
and choose one of these overloading options.
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.
