Olá e bem-vindo.
Nesta aula, quero falar sobre alguns operadores que são um pouco estranhos, no sentido de que
você não pensaria necessariamente que eles são operadores.
Porque todos os operadores que aprendemos até agora apenas apontam para você saber como
usar o símbolo para fazer cálculos em números.
E esses operadores realmente se parecem com funções.
Então, vamos falar sobre o elenco no operador sizeof.
Para falar primeiro sobre o operador de elenco, tenho que
falar um pouco sobre as conversões de tipo, como os dados estão sendo convertidos.
Aprendemos tudo sobre os tipos de dados e os diferentes tipos de dados que existem.
Mas se você está realmente tentando atribuir dados a tipos diferentes,
há algumas conversões implícitas que ocorrem na linguagem de programação c.
Portanto, a conversão de dados entre diferentes tipos pode acontecer automaticamente
e isso é conhecido como conversão
implícita pela linguagem ou explicitamente pelo programa pelo programa ou.
O próprio programador, o desenvolvedor, pode fazer algo.
Eles podem usar um operador de elenco essencialmente para fazer uma conversão.
Os dados que estão sendo convertidos implicitamente são
realmente importantes porque você precisa entender isso porque a maioria dos
programas c que você vai desenvolver para desenvolvê-los de forma eficaz, você precisa
entender essas regras para essas conversões.
Porque muitas vezes você terá números inteiros e números de ponto
flutuante, números decimais e números inteiros.
E você vai usá-los misturando-os às vezes.
E quando o fizer, você tem que saber como as coisas estão sendo convertidas.
Agora você deve tentar evitar isso o máximo que puder usando o operador de elenco.
Mas quando você não usa o operador de elenco, entenda o que está acontecendo.
E o que está acontecendo aqui quando você atribui dados
a diferentes tipos, floats
e doubles, os dados serão truncados ou promovidos.
Esses são dois termos que você vai ouvir.
Os meios truncados tornam-se menos precisos
e os meios promovidos tornam-se mais precisos.
Portanto, tente não misturar esses tipos, mas eles podem ser úteis.
A principal coisa a entender é que sabemos por aulas anteriores que c é muito flexível.
E essa é uma decisão consciente dos designers da linguagem.
Quando eles queriam que fosse flexível, mas novamente como uma compensação, já que essa
liberdade adicional é dada a você,
você pode abusar dela. E então não
abuse dessa ideia de misturar tipos.
Tente usar os mesmos tipos quando puder, inteiros com inteiros, flutuantes com flutuantes.
Mas quando você
não puder, entenda as conversões implícitas ou faça as conversões
explícitas usando o operador de conversão.
Então, novamente, outro problema ou
outro conceito em que c é flexível, mas você não deve abusar dele.
Portanto, sempre que um valor de ponto flutuante é atribuído a uma variável inteira
em c, você tem int x, float y, x
é igual a y.
A parte decimal do número ficará truncada.
Portanto, se você tiver um número int x igual a 0, float
f igual a 12. 125 e você
atribui f a x, o valor de x será 12.
Você vai perder essa precisão. O valor ficará truncado porque
você está atribuindo um float a um int. Um int só sabe como armazenar um número inteiro.
Portanto, ele está sendo convertido automaticamente pela linguagem de programação, pelo compilador, para 12.
Apenas a importação será armazenada.
Agora, se você atribuir uma variável inteira a uma variável de ponto flutuante, que é o
oposto, isso não causará nenhuma alteração no valor do número.
O valor é convertido pelo sistema e armazenado na variável flutuante.
Para que você realmente não precise se preocupar em atribuí-lo a um fluxo.
Se você atribuir 12 a um fluxo, ainda será 12, apenas 12. 0
Quando você realiza aritmética em inteiros e isso
é diferente de apenas atribuir valores atribuindo-os a um float ou float a int, é
quando você tem uma expressão,
está fazendo alguma adição ou subtração, seja qual for o caso.
Ao fazer uma subtração ou adição, você tem dois operandos.
E assim, um operador pode ser um int, um operando pode ser um float.
Você tem que saber como essa conversão está acontecendo.
Portanto, se você tiver dois operandos em uma expressão e ambos
forem inteiros, qualquer parte decimal resultante de uma operação de divisão será descartada.
Então, se você fizer isso, se tiver um inteiro x, isso dá 20.
Você tem um inteiro y, é 12. E você faz 20 dividido por 12.
Você não vai ganhar 1 ponto para algo alguma coisa. Você só vai conseguir 1.
Ele vai descartar todos os resultados e colocá-lo como novo porque, novamente, um int armazena apenas um número inteiro.
Então, dois números são ints e estão fazendo a divisão.
Você não obterá um número de ponto flutuante. Você não obterá um número decimal.
Agora, se um operador é um int e o outro é um float, a operação
será formada como uma operação de ponto flutuante. Então, se você tiver float, f é 20. 0, float a é 10,
um int, então se você fizer uma divisão
lá ou 12, desculpe, seria mais aplicável, então o resultado será um
número de ponto flutuante e o resultado será 1
ponto 8888 ou o que quer que seja 1 ponto qualquer que
seja o caso.
Você não está atribuindo esses dados a nada. Esta é uma expressão que vai retornar.
Então, dois ints em uma divisão, será um número inteiro.
Um int e double ou float, sempre será um float, sempre será uma operação
de ponto flutuante decimal decimal.
E esta é a conversão implícita. Isso é realmente o que você precisa para
entender o que está acontecendo e é feito para você pelo programa, se você não fizer nada.
No entanto, você deve tentar fazer algumas
conversões explícitas, o que pode ser feito com o operador de conversão.
E isso é apenas conhecido como lançar mais ou menos.
E você vê o casting em muitos idiomas quando deseja converter.
E tudo isso é que você está fazendo uma
conversão explícita, está dizendo o que deseja que os dados sejam.
Portanto, você deseja fazer isso se puder, porque,
de outra forma, os dados podem ser rebaixados e perdidos.
Se você fizer dois ints e estiver fazendo a divisão
e eles não forem divididos igualmente, você perderá todos os dados.
Portanto, é possível exigir a conversão de tipo precisa que
você deseja, especificando-a explicitamente.
Isso se chama elenco e consiste em preceder a quantidade
com o nome do tipo desejado entre parênteses.
Portanto, os parênteses e
o nome do tipo constituem o
operador cap.
Você faz um parêntese esquerdo e, em seguida, especifica o tipo de dados e, a seguir, escreve o parêntese.
E isso vai converter o que quer que esteja à
direita dele, qualquer que seja a expressão à direita dele ou mesmo se for apenas uma
única variável, vai converter isso para o que está sempre entre parênteses.
Portanto, o tipo real é desejado, como um longo, ele é substituído por esse tipo de palavra.
Portanto, o operador de tipo passado tem uma precedência mais alta do que todos os operadores aritméticos, exceto o
menos unitário e o mais unitário. Não aprendemos sobre precedência ainda.
Vamos na próxima aula. A precedência é basicamente o
que acontece, a ordem das operações que são realizadas.
Então, vamos fornecer alguns exemplos disso. Tudo que você precisa entender neste ponto é
que o operador typecast tem precedência sobre todos os outros operadores, exceto dois menos unário e mais unário.
Então, aqui está o exemplo, temos um número 21. 51 e temos o operador
de conversão porque sabemos que é operador de conversão porque está
entre parênteses e tem um tipo. E o que estamos basicamente dizendo
é pegar 21. 51 convertê-lo em um int.
Se você pegar um número de ponto flutuante convertido para
ele, ele se tornará apenas o int, o número inteiro, 21.
O mesmo está fazendo do lado direito, está convertendo 26. 99 para um int.
Então, o que realmente aconteceria aqui se você fizesse essa expressão em uma instrução,
seria avaliada como 21 mais 26. Isso truncaria os dados
de 0. 51 para um número inteiro e igual a 0. 99
E esse é o operador de conversão, qualquer coisa entre parênteses que contenha um tipo de dados.
Você verá muito isso.
Se você dissesse 21 mais 26 e o convertesse em flutuadores, seria apenas
adicionar um ponto 0.
Normalmente, você não lança para um tipo mais preciso porque
não será mais preciso.
Você lança de um tipo mais preciso para um menos preciso.
Então, mais como uma flutuação para um int.
Portanto, você verá isso em alguns programas ocasionalmente quando
estiver usando tipos diferentes. Você deve tentar evitar o uso de
tipos diferentes se estiver fazendo aritmética. Mas se você fizer isso, você verá isso.
O tamanho do operador, outro operador que é meio estranho, não
é parecido com muitos dos outros. E isso realmente parece uma função.
Mas o sizeof é um operador. Ele executa uma ação.
Não está fazendo nada orientado à função.
O que ele está fazendo é informando quantos bytes estão ocupados na
memória por um determinado tipo. Portanto, parece uma função porque leva um argumento.
E vamos dar um exemplo disso mas só vai retornar o número de bytes na memória. Lembre-se de que dependendo do
sistema que você está executando, a plataforma
que você está executando, o sistema operacional, a arquitetura do computador,
o hardware, diferentes tipos de dados serão representados em memória com tamanhos diferentes.
Por exemplo, um int pode ter 4 bytes em 1 sistema 8 em outro.
Portanto, o que você pode fazer é usar o operador sizeof como uma palavra-chave especial um operador em ce pode
passar um tipo de dados e ele lhe dirá quantos bytes está usando na memória.
Portanto, sizeof é na verdade um operador, não uma função.
É avaliado em tempo de compilação e não em tempo de execução, a menos que uma matriz de comprimento variável seja usada em seu argumento.
E então vamos mencionar isso. Isso basicamente quer dizer que, se você tiver
uma variável que está dentro do tamanho de
um array, ela não será resolvida em tempo de compilação em tempo de execução, então
não é tão importante saber.
O argumento para o operador sizeof pode ser uma variável, um nome de
array, o nome de um tipo de dados básico, como
int float, o nome de um tipo de dados derivado qualquer coisa ou uma expressão.
Então você poderia dizer sizeof x mais y.
E isso basicamente vai dizer o tamanho de x mais
o tamanho de y ou os números resultantes. Se x for um inteiro, y for um int e seu tamanho de 16,
isso diria que é uma polegada de 4 bytes.
Se fosse um número flutuante e o resultado fosse uma aritmética de ponto flutuante, então seria
um número flutuante de 8 bytes ou algo assim.
Mas você pode usá-lo para muitas coisas e deve usá-lo para muitas coisas. Sizeof int, por exemplo, resultará no
número de bytes ocupados por uma variável do tipo int.
Portanto, isso retornaria 4 ou 8 dependendo do seu sistema.
Você também pode aplicar o operador sizeof a uma expressão, como mencionei,
o resultado é o tamanho do valor.
Isso resulta da expressão da área. Portanto, se dois ints juntos, eles ainda serão um int.
Portanto, ainda terá um tamanho. Mas você verá o operador sizeof também sendo usado quando falarmos sobre ponteiros.
Eu queria falar sobre isso agora porque é uma operadora.
Mas vamos fornecer muitos outros exemplos disso e do elenco ao longo da aula à
medida que falamos sobre mais conceitos.
Especificamente, o operador sizeof entra em ação muito
mais quando falamos sobre ponteiros,
porque quando você está calculando quanta memória alocar, que são os ponteiros,
você usa sizeof porque quer ser preciso.
Mas você também pode usá-lo para outras coisas.
Portanto, use o operador sizeof sempre que possível para evitar ter um cálculo de tamanhos de código
rígido em seu programa.
Os números mágicos de tamanhos de código rígido não são uma coisa boa porque,
novamente, se você estiver em um sistema diferente, se você fosse
codificar 4 em 1 sistema para um int, no outro sistema pode ser um
8, então use sizeof tanto você pode e veremos isso se tornar muito
mais compreensível quando falamos sobre ponteiros.
Outros operadores um
pouco estranhos são o operador asterisco.
Você pode ter dito para si mesmo asterisco, já falamos sobre isso na multiplicação.
Mas esse asterisco leva dois operandos, um à esquerda e outro à direita.
Se você aplicar o operador asterisco a
uma variável e apenas disser o nome da variável estrela com apenas um argumento
à direita, isso representará outra coisa. Na verdade, representa um ponteiro.
Ele está desreferenciando um ponteiro.
E, novamente, não vou insistir nisso agora, porque vamos passar por
isso quando falarmos sobre ponteiros.
Mas se você vir algo como a estrela a, não se desespere, isso é realmente válido.
Isso faz com que o asterisco seja o operador do ponteiro.
Você também pode ver os dois pontos do ponto de interrogação.
Este é um operador usado para a tomada de decisões.
Se a condição for verdadeira, se a coisa à esquerda for verdadeira, o valor à
direita após os dois pontos é avaliado e assim por diante, caso contrário.
É uma notação abreviada para uma instrução if-else.
É um operador ternário, é chamado. Mas, novamente, não quero discutir
isso com muitos detalhes agora porque
vamos falar sobre isso quando falarmos sobre nossos
assuntos específicos.
Falaremos sobre o operador de giro quando falarmos sobre declarações de decisão. Falaremos sobre o
operador de asterisco unário quando falarmos sobre ponteiros.
Mas se você vir isso agora e eu gostaria de mencionar agora, porque eles são tecnicamente operadores, mas
entenderemos seus casos de uso quando falarmos sobre esses conceitos. Obrigada.