Bonjour et bienvenue.
Dans cette conférence, je veux parler de quelques opérateurs qui sont un peu étranges dans le sens où
vous ne pensez pas nécessairement qu'ils sont des opérateurs.
Parce que tous les opérateurs que nous avons appris jusqu'à présent indiquent simplement que vous savez comment
utiliser le symbole pour faire des calculs sur des nombres.
Et ces opérateurs ressemblent en fait à des fonctions.
Parlons donc de la distribution de l'opérateur sizeof.
Afin de parler d'abord de l'opérateur de distribution, je dois
vous parler un peu des conversions de type, de la façon dont les données sont converties.
Nous avons tout appris sur les types de données et les différents types de données.
Mais si vous essayez réellement d'attribuer des données à différents types, il y
a des conversions implicites qui se produisent dans le langage de programmation c.
Ainsi, la conversion de données entre différents types peut se produire automatiquement
et cela est appelé conversion implicite par
le langage ou explicitement par le programme par le programme ou.
Le programmeur lui-même le développeur peut faire quelque chose.
Ils peuvent utiliser un opérateur de conversion essentiellement pour effectuer une conversion.
Les données qui sont converties implicitement sont vraiment
importantes parce que vous devez comprendre cela parce que la plupart
des programmes c que vous allez développer pour les développer efficacement, vous devez
comprendre ces règles pour ces conversions.
Parce que vous allez souvent avoir des entiers et des nombres à virgule flottante,
des nombres décimaux et des nombres entiers.
Et vous allez les utiliser en les mélangeant parfois.
Et quand vous le faites, vous devez savoir comment les choses sont converties.
Maintenant, vous devriez essayer d'éviter cela autant que vous le pouvez en utilisant l'opérateur de cast.
Mais lorsque vous n'utilisez pas l'opérateur de distribution, comprenez ce qui se passe.
Et que se passe-t-il ici lorsque vous attribuez des données à différents
types de flottants et de
doubles, les données vont être tronquées ou être promues.
Ce sont deux termes que vous allez entendre.
Le moyen tronqué devient moins précis
et promu signifie qu'il devient plus précis.
Alors essayez de ne pas mélanger ces types mais ils peuvent être utiles.
La principale chose à comprendre est que nous savons d'après des conférences précédentes que c est très flexible.
Et c'est une décision consciente des concepteurs du langage.
Lorsqu'ils voulaient que cela soit flexible, mais encore une fois comme un compromis, comme
cette liberté supplémentaire vous est donnée,
vous pouvez en abuser. Et alors n'abusez pas
de cette idée de mélanger les types.
Essayez d'utiliser les mêmes types lorsque vous le pouvez, des entiers avec des entiers, des flottants avec des flottants.
Mais lorsque vous
ne pouvez pas, comprenez les conversions implicites ou effectuez les conversions
explicites à l'aide de l'opérateur de conversion.
Encore une fois, un autre problème
ou un autre concept où c est flexible, mais il ne faut pas en abuser.
Ainsi, chaque fois qu'une valeur à virgule flottante est affectée à une variable entière
dans c, vous avez donc int x, float y, x
est égal à y.
La partie décimale du nombre va être tronquée.
Donc, si vous avez un nombre int x égal à 0, float f
est égal à 12. 125 et vous affectez
f à x, la valeur de x va être 12.
Vous allez perdre cette précision. La valeur va être tronquée
car vous affectez un flottant à un int. Un int ne sait que stocker un nombre entier.
Il est donc automatiquement converti par le langage de programmation, par le compilateur en 12.
Seule l'importation sera stockée.
Désormais, si vous affectez une variable entière à une variable à virgule flottante, ce qui est le
contraire, cela n'entraîne aucune modification de la valeur du nombre.
La valeur est convertie par le système et stockée dans la variable flottante.
Pour que vous n'ayez pas vraiment à vous soucier de l'affecter dans un flux.
Si vous attribuez 12 à un flux, ce sera toujours 12, juste 12. 0.
Lorsque vous effectuez de l'arithmétique sur des entiers et
que cela diffère du simple fait d'assigner des valeurs en l'assignant dans un float ou float à
int, c'est lorsque vous avez une
expression, que vous faites une certaine soustraction, quel que soit le cas.
Lorsque vous effectuez une soustraction ou une addition, vous avez deux opérandes.
Et donc un opérateur peut être un int, un opérande peut être un flottant.
Vous devez savoir comment cette conversion se produit.
Donc, si vous avez deux opérandes dans une expression et qu'ils sont tous
les deux des entiers, alors toute partie décimale résultant d'une opération de division est ignorée.
Donc, si vous le faites si vous avez un entier x, c'est 20.
Vous avez un entier y, c'est 12. Et vous faites 20 divisé par 12.
Vous n'obtiendrez pas 1 point quelque chose quelque chose. Vous allez juste en avoir 1.
Il va supprimer tous les résultats et en mettre un nouveau car encore une fois, un int ne stocke qu'un nombre entier.
Donc, deux nombres sont des entiers et ils font la division.
Vous n'obtiendrez pas un nombre à virgule flottante. Vous n'obtiendrez pas un nombre décimal.
Maintenant, si un opérateur est un int et l'autre est un float, alors l'opération va
être formée comme une opération en virgule flottante. Donc, si vous avez un flotteur f, c'est 20. 0, float a est 10,
un int, alors si vous faites une division
là-bas ou 12, je suis désolé que ce soit plus applicable, alors le
résultat va faire un nombre à virgule flottante et
le résultat sera 1 virgule 8888 ou quoi que ce soit 1 point
quoi qu'il en soit.
Vous n'attribuez ces données à rien. C'est une expression de ce que ça va retourner.
Donc, deux entiers dans une division, ça va être un nombre entier.
Un int et double ou float, ça va toujours être un float, ça va toujours être une
opération en virgule flottante décimale décimale.
Et c'est la conversion implicite. C'est vraiment ce dont vous avez besoin pour comprendre
ce qui se passe et ce qui est fait pour vous par le programme si vous ne faites rien.
Cependant, vous devriez essayer d'effectuer des
conversions explicites, ce que vous pouvez faire avec l'opérateur de conversion.
Et cela est simplement appelé casting plus ou moins.
Et vous voyez la diffusion dans de nombreuses langues lorsque vous souhaitez convertir.
Et tout ce que vous faites, c'est que vous faites une
conversion explicite, vous dites ce que vous voulez que les données soient.
Vous voulez donc le faire si vous le pouvez,
car sinon les données pourraient être rétrogradées, elles pourraient être perdues.
Si vous faites deux entiers et que vous faites une division
et qu'ils ne sont pas répartis également, vous allez perdre toutes ces données.
Il vous est donc possible d'exiger la conversion de type précise que
vous souhaitez en la spécifiant explicitement.
Cela s'appelle une distribution et consiste à faire précéder la
quantité du nom du type souhaité entre parenthèses.
Ainsi, les parenthèses et
le nom du type constituent
l'opérateur cap.
Vous faites une parenthèse gauche, puis vous spécifiez le type de données, puis écrivez des parenthèses.
Et cela va convertir tout ce qui se trouve à
sa droite, quelle que soit l'expression à sa droite ou même s'il ne s'agit que d'une seule
variable, cela va convertir cela en ce qui se trouve entre parenthèses.
Donc, le type réel est souhaité, tel qu'un long, il est remplacé par ce type de mot.
Ainsi, l'opérateur de type passé a une priorité plus élevée que tous les opérateurs arithmétiques, à l'exception du
moins unitaire et de l'unité plus. Nous n'avons pas encore appris la préséance.
Nous allons dans la prochaine conférence. La priorité est essentiellement ce
qui se passe, l'ordre des opérations qui sont effectuées.
Nous allons donc en donner quelques exemples. Tout ce que vous devez comprendre à ce stade est que
l'opérateur de conversion de type a la priorité sur tous les autres opérateurs, à l'exception de deux moins unaire et un plus unaire.
Donc, ici, par exemple, nous avons un numéro 21. 51 et nous avons l'opérateur
cast parce que nous savons que c'est l'opérateur cast parce qu'il est
entre parenthèses et qu'il a un type. Et ce que nous disons essentiellement,
c'est prendre 21. 51 le convertir en un entier.
Si vous prenez un nombre à virgule flottante converti
en lui, il devient simplement le entier, le nombre entier, 21.
Il en va de même du côté droit, il convertit 26. 99 à un int.
Donc, que se passerait-il réellement ici si vous faisiez cette expression dans une déclaration,
cela donnerait 21 plus 26. Cela tronquerait les données
de 0. 51 à un nombre entier et identique à 0. 99.
Et c'est donc l'opérateur de cast, tout ce qui se trouve entre parenthèses qui contient un type de données.
Vous verrez cela beaucoup.
Si vous deviez dire 21 plus 26 et que vous le jetiez en flotteurs, cela
ajouterait simplement un point 0.
Habituellement, vous ne lancez pas un type plus précis car vous n'allez
pas être plus précis.
Vous passez d'un type plus précis à un type moins précis.
Donc plus comme un float à un int.
Vous verrez donc cela dans certains programmes de temps en temps
lorsque vous utilisez différents types. Vous devriez essayer d'éviter d'utiliser différents types
si vous faites de l'arithmétique. Mais si vous le faites, vous verrez ceci.
La taille de l'opérateur, un autre opérateur assez étrange,
pas similaire à beaucoup d'autres. Et cela ressemble en fait à une fonction.
Mais la taille est un opérateur. Il effectue une action.
Il ne fait rien axé sur la fonction.
Ce qu'il fait, c'est vous dire combien d'octets sont occupés en mémoire
par un type donné. Cela ressemble donc à une fonction car il prend un argument.
Et nous allons en donner un exemple mais cela va simplement renvoyer le nombre d'octets en mémoire. N'oubliez pas que selon le
système que vous exécutez, la plate-forme que
vous exécutez, le système d'exploitation, l'architecture de l'ordinateur, le matériel, différents
types de données vont être représentés en mémoire avec des tailles différentes.
Par exemple, un int peut être de 4 octets sur 1 système 8 sur un autre.
Donc, ce que vous pouvez faire, c'est utiliser l'opérateur sizeof comme un mot clé spécial un opérateur dans c et vous
pouvez passer un type de données et il vous dira combien d'octets il utilise en mémoire.
Donc sizeof est en fait un opérateur, ce n'est pas une fonction.
Il est évalué au moment de la compilation et non au moment de l'exécution, sauf si un tableau de longueur variable est utilisé dans son argument.
Et nous allons donc mentionner cela. Cela signifie essentiellement que si vous avez une variable
qui se trouve à l'intérieur de la taille
d'un tableau, elle ne sera pas résolue au moment de la compilation au moment de l'exécution, donc
pas si important à savoir.
L'argument de l'opérateur sizeof peut être une variable, un nom de tableau,
le nom d'un type de données de base,
comme int float, le nom d'un type de données dérivé ou une expression.
Vous pourriez donc dire sizeof x plus y.
Et cela va simplement dire la taille de x plus
la taille de y ou les nombres résultants. Si x est un entier, y est un int et sa taille est de
16, cela dirait que c'est un pouce de 4 octets.
Si c'était int, un était un flottant et le résultat était une arithmétique en virgule flottante, alors ce
serait un flottant de 8 octets ou quelque chose comme ça.
Mais vous pouvez l'utiliser pour beaucoup de choses, et vous devriez l'utiliser pour beaucoup de choses. Sizeof int, par exemple, donnera
le nombre d'octets occupés par une variable de type int.
Donc, cela renverrait 4 ou 8 selon votre système.
Vous pouvez également appliquer l'opérateur sizeof à une expression, comme je l'ai mentionné,
le résultat est la taille de la valeur.
Cela résulte de l'expression de la zone. Donc, si deux entiers ensemble, ils seront toujours un int.
Donc ça va encore être une taille. Mais vous verrez que l'opérateur sizeof est également utilisé lorsque nous parlons de pointeurs.
Je voulais en parler maintenant parce que c'est un opérateur.
Mais nous allons fournir beaucoup plus d'exemples de cela et de la distribution dans toute la classe au fur et à
mesure que nous parlerons de plus de concepts.
Plus précisément, l'opérateur sizeof entre en jeu beaucoup plus lorsque
nous parlons de pointeurs, car lorsque
vous calculez la quantité de mémoire à allouer, ce que sont les pointeurs, vous
utilisez sizeof parce que vous voulez être précis.
Mais vous pouvez également l'utiliser pour d'autres choses.
Utilisez donc l'opérateur sizeof autant que possible pour éviter d'avoir un calcul des tailles de code
dur dans votre programme.
Les nombres magiques de tailles de code dur ne sont pas une bonne chose car encore
une fois, si vous êtes sur un système différent, si vous deviez coder
en dur un système 4 sur 1 pour un int, sur l'autre système pourrait être
un 8, alors utilisez sizeof autant que vous pouvez et nous verrons cela devenir beaucoup
plus relatable lorsque nous parlons de pointeurs.
D'autres opérateurs qui
sont un peu étranges sont l'opérateur astérisque.
Vous vous êtes peut-être dit astérisque, nous en avons déjà parlé en multiplication.
Mais cet astérisque prend deux opérandes, l'un à gauche et l'autre à droite.
Si vous appliquez l'opérateur astérisque à une variable
et que vous dites simplement le nom de la variable étoile avec un seul argument
à droite, cela représente autre chose. Cela représente en fait un pointeur.
C'est déréférencer un pointeur.
Et encore une fois, c'est que je ne vais pas insister là-dessus maintenant parce que nous allons
passer par là quand nous parlerons de pointeurs.
Mais si vous voyez quelque chose comme l'étoile a, ne paniquez pas, c'est vraiment valable.
Cela fait l'astérisque l'opérateur de pointeur.
Vous pouvez également voir le point d'interrogation deux-points.
C'est un opérateur utilisé pour la prise de décision.
Si la condition est vraie, si la chose à gauche est vraie, alors la valeur
à droite après les deux points est évaluée et ainsi de suite.
C'est une notation abrégée pour une instruction if-else.
C'est un opérateur ternaire, ça s'appelle. Mais encore une fois, je ne
veux pas vraiment en discuter en détail
maintenant parce que nous allons en parler lorsque nous parlerons de
nos sujets spécifiques.
Nous parlerons de l'opérateur de tournage lorsque nous parlerons d'énoncés de décision. Nous parlerons de
l'opérateur astérisque unaire lorsque nous parlerons de pointeurs.
Mais si vous voyez cela maintenant et que je voulais mentionner maintenant, car ce sont techniquement des opérateurs, mais
nous comprendrons leurs cas d'utilisation lorsque nous parlerons de ces concepts. Merci.