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.
Constructeur de copie
Loading...
Do curso por École Polytechnique Fédérale de Lausanne
Introduction à la programmation orientée objet (en C++)
190 classificações
Explore Related Videos
At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you
École Polytechnique Fédérale de Lausanne
190 classificações
Na lição
Constructeurs et destructeurs
Cette semaine aborde l'initialisation des objets (via ce qu'on appelle des « constructeurs »), ainsi que ce qui se passe « en fin de vie » des objets.
Conheça os instrutores
Jamila SamDr
School of Computer and Communication Sciences
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
In this episode, we will focus on another particular
constructor : the copy constructor. Namely, we will wonder
what happens when an object is initialized with a copy
of another object of the same class.
C++ gives us a way to do instance copies. For example,
we have here a first r1 instance of the "Rectangle" class
which has been initialized through a usual constructor, here with
two parameters. This results in the following situation in the memory.
This instance has thus been initialized to the values 12.3 and 24.5. We have here
another "r2" instance of the very same "Rectangle" class. r2 is initialized
with a copy of r1.
This results in the following situation.
r2 is initialized with a copy of the values, that is, 12.3 for the height
and 24.5 for the width.
An initial copy occurs upon the creation of r2.
Naturally, "2 and r1 are distinct instances, living their life indepently
in the memory. Simply, r2 is initialized, upon its building,
with a copy of the values of r1. This is called the copy constructor.
Here is another example where we call the copy constructor.
Is this correct?
Yes! We indeed have a copy here since we are passing parameters
by value. Remember, that when we pass parameters by value, the arguments
are evaluated and copied into the function parameters.
We thus inded have a copy of r1 which will be copied into "r", a parameter
of the "f" function. During the call to f of r1,
the copy constructor of the "Rectangle" class is called.
The copy constructor is called because of passing parameters by value here;
thus resulting in a copy. Obviously, if we pass the parameters by reference, there is
no copy at all; the copy constructor is thus not called.
The goal of the copy constructor is to initialize an instance with a copy
of another instance of the same class
Its prototype is thus fixed. Since it is a constructor,
its name is none other than the class name. And since it initializes
with a copy of another instance of the same, it will only
receive one single parameter here. This parameter is another instance of the same class.
We will pass this other instance by constant reference in other to avoid
passing parameters by value which would create another copy.
In this case, we would enter an infinite loop! making a copy of a copy of a copy...
Therefore, we use the passage by reference. Also, the copy constructor
does not modify the received instance but only modifies the instance
it is currently initializing. Thus, it does not modified the received
instance : this is a constant reference.
For example, in our rectangle case, we would have here
a constructor called "Rectangle" for the "Rectangle" class.
It would receive another instance of the same "Rectangle" class, passed by
constant reference. Of course, it would use the initialization section
starting with a colon.
Here initializing the height of the instance it is creating
with the value of the height of the other instance received
as parameter. And similarly, initializing the width of the
instance it is creating with the copy of the width of the other instance
received as parameter.
let us go back to the previous example. We have an r2 instance
created with a copy of the r1 instance. We indeed have a call to the copy
constructor. In this case, r1 is the received parameter
and r2 the initialized instance. Here, we thus have "r2.hauteur"
receiving "r1.hauteur" and "r2.largeur" receiving "r1.largeur".
By the way, often it is not necessary to write explicitly the
copy constructor. Indeed, the C++ compiler provied us with
a default one.
There is always a copy constructor furnished by default. We call it
copy constructor is build
This copy constructor carries out a so-called shallow copy.
This means that it will copy the parameter attributes of the other
received instance one after the other in order to process the current initialization.
For example, in the case of our rectangle, we did not have to write the previous
constructor. In this simple case, it is automatically generated by
the compiler. It is thus not necessary to write this constructor which
copies the "hauteur" attribute of the instance received as parameter
into the "hauteur" of the instance we are currently initializing
and copies the "largeur" of the received instance into the current instance and so on
for every other possible attributes. This is how the default
copy constructor is build
Very often, this shallow copy suffices. Most of the time, you thus will not
need to write the copy constructor explicitly.
In certain cases though (we are anticipating on upcoming examples which we will
face much later in this course) it will be necessary to express
our very own copy constructor. We will have to resort to a so-called
deep copy.
We are showing it already, anticipating on upcoming concepts.
Here is a golden rule. If you have to touch one member of this triumvirate :
the copy constructor, the destructor and the assignment operator
(that is, the equal operator), then you must at least
ask yourselves wether you should also redefine
the other two.
This golden rule anticipates on the concepts of the destructor
and the assignment operator which will be presented later.
We have seen that a default copy constructor is automatically provided.
In certain cases, we could not wish to authorize the copy.
Since C++ 2011, we can explicitly ask to remove the copy constructor.
This can be useful when we are dealing, for example, with classes containing
many on object. For example we could have the simulator of a physical word
which we do not wish to copy with all its objects.
We wish to prevent copies of this huge object to be made since it contains
many, many things.
This can be done with a particular syntax written : " = delete ".
We simply need to write " = delete " just after the prototype
of the copy constructor.
For example, we have here a class we do not wish to copy.
We will call it "PasCopiable" (TN: means "NotCopiable). Here are, as usual,
all the class defenition. In order to avoid the copy we will start
by adding a copy constructor. This is indeed a constructor, for it has the same
method name as the name of the class. Here we received a parameter by constant
reference. Its type is the same as the class, thus "PasCopiable".
Now, we only need to add, here,
at the end of the prototype " = delete ".
Therefore, we cannot call the copy constructor
anymore since it has been destroyed, deleted; it exists no longer.
Now, this square is not copiable; we can simply initialize it
with the other available constructors.
Instance copies are not longer possible.
Voilà! This concludes this episode on the copy constructors in C++.
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.
© 2019 Coursera Inc. Todos os direitos reservados.
