Explore
For Enterprise
Join for Free
Log In

Arts et humanités
Business
Informatique
Science des données
Technologies de l'information
santé
Mathématiques et logique
Développement personnel
Sciences physiques et ingénierie
Sciences sociales
Apprentissage des langues
Diplômes
Certificats

Explorez l'intégralité de Coursera

Parcourir
Rechercher
For Enterprise
Connexion
Inscrivez-vous gratuitement

Surcharge d'opérateurs : introduction

Loading...

Introduction à la programmation orientée objet (en C++)

École polytechnique fédérale de Lausanne

4.8 (200 notes) | 21K étudiants inscrits

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.

Visualiser le programme de cours

Avis

4.8 (200 notes)

5 stars
171 ratings
4 stars
27 ratings
3 stars
2 ratings

BB

Mar 19, 2016

Cours de qualité excellente. Vraiment le top en termes de pédagogie et de clarté comparé à l'ensemble des cours disponibles sur le net.

RJ

Oct 27, 2016

Superbe cours. les explications sont claires et avec un peu de travail, tout peut être assimilé. Merci aux profs !!!

À partir de la leçon

Surcharge des opérateurs

Cette semaine nous étudions comment étendre les opérateurs du langage C++ à nos propres classes.

Variables et méthodes de classe13:10

Surcharge d'opérateurs : introduction 11:09

Surcharge d'opérateurs : surcharge externe 17:28

Surcharge d'opérateurs : surcharge interne 12:08

Surcharge d'opérateurs : compléments24:04

Enseigné par

Jamila Sam
Dr
Jean-Cédric Chappelier
Dr.

Transcription

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.

© 2019 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play

Coursera
À propos
Direction
Carrières
Catalogue
Certificats
Certificats MasterTrack™
Diplômes
For Enterprise
For Government

Communauté
Learners
Partners
Developers
Beta Testers
Translators

Se connecter
Blog
Facebook
LinkedIn
Twitter
Instagram
YouTube
Blog Tech

Plus
Conditions
Confidentialité
Aide
Accessibilité
Presse
Contact
Répertoire
Filiales