c operators types
Um estudo completo de operadores em C ++ com exemplos:
Nisso Série de treinamento intensivo em C ++, aprendemos sobre os vários conceitos em C ++ como variáveis, classes de armazenamento, qualificadores de tipo, etc. em nossos tutoriais anteriores. Também descobrimos como podemos modificar essas variáveis.
Para fazer essas modificações, precisamos realizar operações nessas variáveis e constantes e, para realizar essas operações, fazemos uso de operadores.
Operadores são símbolos que atuam sobre variáveis ou outras entidades chamadas operandos e realizam operações matemáticas ou lógicas para modificar seus valores e produzir resultados de acordo.
O que você aprenderá:
Operadores em C ++
Os operadores formam a base básica de qualquer linguagem de programação. Sem operadores, não podemos modificar ou manipular as entidades das linguagens de programação e, portanto, não podemos produzir os resultados desejados. C ++ é muito rico em operadores integrados que discutiremos em detalhes neste tutorial.
Em C ++, a maioria dos operadores são operadores binários, ou seja, esses operadores requerem dois operandos para realizar uma operação. Poucos operadores como o operador ++ (incremento) são o operador unário, o que significa que operam em apenas um operando.
como executar arquivos .jar no Windows 10
Existe também um operador ternário em C ++ chamado Operador Condicional que leva três operandos. Aprenderemos sobre isso em detalhes na última parte do tutorial.
Tipos de operadores em C ++
Os operadores em C ++ são classificados conforme mostrado abaixo:
Vamos explorar cada tipo de operador C ++ em detalhes !!
Operadores aritméticos
Operadores aritméticos são usados para realizar operações matemáticas básicas em operandos.
C ++ suporta as seguintes operações aritméticas:
| Operador | Binário / unário | Descrição |
|---|---|---|
| - | Unário | Operador de decremento - diminui o valor do operando em 1 |
| + | Binário | Adição de dois operandos |
| - | Binário | Subtração de dois operandos |
| * | Binário | Multiplicação de dois operandos |
| / | Binário | Divisão de dois operandos |
| % | Binário | Operador de módulo - o resultado é o resto da divisão |
| ++ | Unário | Operador de incremento - aumenta o valor do operando em 1 |
O exemplo a seguir demonstra os primeiros cinco operadores aritméticos em C ++
#include #include using namespace std; int main() { int op1=3,op2=4; float op3=10.1,op4=5.4; cout<<'Operands are op1 = '< Podemos entender isso melhor usando o seguinte exemplo. #include #include using namespace std; int main() { int x=4,y; y = ++x; cout<<'PreIncrement:Value of x = '<Operadores lógicos Operadores lógicos são usados para avaliar uma combinação de condições / restrições para obter um valor resultante. O resultado da avaliação de uma expressão booleana é booleana, que pode ser verdadeira ou falsa.
C ++ suporta os seguintes operadores lógicos:
Operador Descrição 7 L-> R <<
>> Deslocamento à esquerda
Deslocamento bit a bit para a direita && E lógico: retorna verdadeiro se ambas as condições forem verdadeiras, caso contrário, retorna falso. || OR lógico: retorna verdadeiro se uma das condições for verdadeira. Retorna falso quando ambas as condições são falsas. ! NOT lógico: nega a condição.
C ++ emprega um método de curto-circuito para avaliar expressões lógicas. Nesse caso, C ++ deve avaliar apenas a primeira expressão / operando da expressão lógica para fornecer o resultado. Por exemplo, para o operador lógico AND (&&), C ++ avalia apenas a primeira expressão. Se for falso, o resultado será falso mesmo se a segunda condição for verdadeira.
Da mesma forma, para OR lógico (||), ele avalia apenas a primeira expressão. Se a primeira expressão for verdadeira, o resultado será verdadeiro, portanto, não é necessário avaliar a segunda expressão.
Abaixo está um exemplo que mostra o uso de operadores lógicos.
#include #include using namespace std; int main() int a=10, b=8,c=12,d=14; if(!(a==0)) cout<<'a is not zero'< Resultado:
a não é zero
E lógico é verdadeiro
OR lógico é verdadeiro
No programa acima, usamos todos os três operadores lógicos para avaliar as expressões e imprimir os resultados.
Operadores Relacionais
Operadores relacionais ou de comparação são usados para comparar dois operandos. O resultado da avaliação é verdadeiro ou falso.
C ++ suporta os seguintes Operadores Relacionais:
Operador Descrição !ERRO! operador inesperado '=' Avalia se dois operandos são iguais. Retorna verdadeiro se igual, senão retorna falso. ! = (diferente de) Complementa o operador ‘igual a’. Retorna verdadeiro se os operandos não forem iguais. Caso contrário, falso. <(less than) Retorna verdadeiro se o primeiro operando for menor que o segundo. Caso contrário, falso. <=(less than equal to) Retorna verdadeiro se o primeiro operando for menor ou igual ao segundo operando. Caso contrário, falso. > (maior que) Retorna verdadeiro se o primeiro operando for maior que o segundo. Caso contrário, falso. > = (maior que igual a) Retorna verdadeiro se o primeiro operando for maior que igual ao segundo. Caso contrário, falso.
Veja o exemplo de programa abaixo para entender os Operadores Relacionais.
#include #include using namespace std; int main() { int a=10, b=8,c=12,d=14; if(a==b) cout<<'a is equal to b'< Resultado:
a não é igual a b
c não é igual a d
(a + b) menor que / igual a (c + d)
(a-b) maior que / igual a (d-c)
No programa acima, vemos o uso de operadores relacionais e a maneira como eles avaliam as expressões fornecidas.
Observe que podemos fornecer não apenas valores, mas também variáveis e expressões nas declarações condicionais.
Operadores bit a bit
Operadores bit a bit em C ++ operam em bits dos operandos fornecidos. Operadores bit a bit são aplicados apenas a tipos integrais como inteiro, caractere, etc., e não em tipos de dados como float, double, etc.
A seguir estão os operadores bit a bit compatíveis com C ++:
Operadores Descrição & (Binário E) Executa a operação AND nos bits do operando 1 e operando 2. | (Binário OU) Executa a operação OR nos bits do operando 1 e operando 2. ^ (Binário XOR) Executa a operação XOR nos bits do operando 1 e operando 2. ~ (Complemento binário) Pega um operando e inverte seus bits. <<( Binary left shift operator) Desloca bits do primeiro operando para a esquerda para um número de bits especificado pelo segundo operando. >> (operador binário de deslocamento à direita) Desloca bits do primeiro operando para a direita para uma série de casas especificadas pelo segundo operando.
Esses operadores bit a bit operam em operandos de maneira bit a bit. As tabelas de verdade para as operações AND, OR e XOR são fornecidas abaixo.
Considere aeb como dois bits nos quais as operações AND, OR e XOR devem ser realizadas.
As tabelas de verdade para o mesmo são as fornecidas abaixo:
para b a e b a | b a ^ b 0 0 0 0 0 1 0 0 1 1 0 1 0 1 1 1 1 1 1 0
Vamos dar um exemplo para entender as operações bit a bit.
Seja a = 8 e b = 4
A representação binária de a e b é a seguinte:
a = 8 1000
a = 4 0100
a & b 0000 = 0
a | b 1100 = 12
a ^ b 1100 = 12
No exemplo acima, vemos que o bit a bit AND de 8 e 4 é 0. bit a bit OR de 8 e 4 é 12 e o bit a bit XOR de 8 e 4 também é 12.
Esta é a maneira pela qual as operações bit a bit são realizadas pelos operadores bit a bit.
Um exemplo demonstrando os operadores bit a bit.
#include #include using namespace std; int main() int a=8,b=4,c; c = a&b; cout<<'Result of & : '< Resultado:
Resultado de &: 0
Resultado de | : 12
Resultado de ^: 12
Resultado de<< by 2 bits: 32
Resultado de >> por 2 bits: 1
Resultado de ~: -4
No programa acima, demonstramos o uso de operadores bit a bit e também imprimimos a saída de cada uma das operações.
Operadores de atribuição
O operador de atribuição “=” é usado para atribuir um valor a uma variável. O LHS do operador de atribuição é uma variável e RHS é o valor que deve ser atribuído à variável. O valor do lado direito deve ser do mesmo tipo que o da variável do lado esquerdo.
Observe a diferença entre os operadores ‘=’ e ‘==’. O primeiro é o operador de atribuição e o último é o operador de igualdade.
A operação de atribuição ocorre da direita para a esquerda. Além do operador de atribuição ‘=’, existem outras variações do operador de atribuição que são conhecidas como ‘operadores de atribuição compostos”. Esses operadores realizam uma operação além da atribuição.
A tabela a seguir nos dá uma descrição desses operadores de atribuição.
Operador Descrição = Atribui o valor do operando RHS ao operando LHS + = Adiciona o operando RHS ao operando LHS e atribui o resultado ao operando LHS. - = Subtrai o operando RHS ao operando LHS e atribui o resultado ao operando LHS * = multiplica o operando RHS para o operando LHS e atribui o resultado ao operando LHS / = divide o operando RHS em operando LHS e atribui o resultado ao operando LHS
Conforme mostrado na tabela acima, Se x e y forem operandos, x + = y é equivalente a x = x + y.
Similarmente,
x - = y é equivalente a x = x-y.
x * = y é equivalente a x = x * y.
perguntas e respostas do exame sql pdf
x / = y é equivalente a x = x / y.
O exemplo de programação abaixo demonstra esses operadores de atribuição.
#include #include using namespace std; int main() { int x,y; cout<>y; x = y; cout<<'
Value of x = '< Resultado:
Insira a variável de entrada y: 4
Valor de x = 4
a + = b: 8
c - = b: 3
a * = b: 40
b / = c: 1
No exemplo acima, demonstramos a atribuição, bem como os operadores de atribuição compostos.
Observação: Também podemos combinar os outros operadores binários como%,<>, &, |, ^, etc. em instruções de atribuição compostas, além daquelas que já foram demonstradas.
Outros Operadores
Até agora, exploramos todos os principais operadores em C ++. Existem mais alguns operadores C ++ adicionais que precisam de nossa atenção.
Esses operadores incluem:
(i) tamanho do operador
sizeof é um operador unário amplamente usado em C e C ++. Sizeof retorna o tamanho de seu operando. O valor de retorno é geralmente um tipo integral sem sinal denotado por ‘size_t’.
O operador Sizeof tem muitos usos nas linguagens C e C ++. Pode ser usado para saber o tamanho das variáveis, arrays ou expressões e até mesmo para alocar os blocos de memória.
(ii) Operador ternário condicional
O operador condicional em C ++ pode ser usado como um substituto para a instrução if-else.
A sintaxe geral do operador condicional é:
Doença? expressão1: expressão2;
Se a condição for verdadeira, a expressão 1 será avaliada. Se a condição for falsa, a expressão2 será avaliada.
Observe que a expressão1 e a expressão2 precisam ter os mesmos tipos de dados para evitar possíveis erros.
Leitura sugerida => Operador ternário em C #
(iii) Operador de vírgula
O operador vírgula, que é representado como um token ‘,’ pode ser usado como um operador, bem como um separador.
Como um operador, uma vírgula é usada quando há mais de uma expressão a ser avaliada. Apenas a expressão mais à direita é atribuída a LHS.
Por exemplo,considere a seguinte expressão.
x = (y = 4, y + 1);
Nesta expressão, temos duas expressões no lado direito separadas por uma vírgula. Aqui, a vírgula atua como um operador. Primeiro, a expressão, y = 4 será avaliada. Em seguida, a próxima expressão y + 1 será avaliada usando o resultado da primeira expressão, ou seja, y = 4. Assim, o valor de y + 1 será 5 e este valor será atribuído a x.
Como separador, uma vírgula pode ser usada em qualquer lugar para separar definições, lista de parâmetros, etc.
(iv) Operador de acesso de membro
Existem dois operadores que são usados para acessar os membros individuais de classes, estruturas ou uniões em C ++. Estes são o operador ponto (.) E o operador seta (->). Aprenderemos esses operadores em detalhes quando aprendermos a programação orientada a objetos em C ++.
O exemplo abaixo demonstra o uso de sizeof, Vírgula e Operador condicional.
#include #include using namespace std; int main() { int x,y; x = (y=3,y+4); cout<<'Value of x = '< Resultado:
Valor de x = 7
A variável x é maior que 5
sizeof (x): 4 sizeof (y): 4
A captura de tela para o mesmo é fornecida abaixo.
Conforme mostrado no programa acima, primeiro temos duas variáveis declaradas e separadas por uma vírgula. (vírgula como separador). A seguir, temos um operador vírgula com duas expressões. Como podemos ver na saída, o valor da expressão mais à direita é atribuído à variável x. A seguir, demonstramos o operador condicional para avaliar se x é menor que 5.
Finalmente, demonstramos o uso do operador sizeof. Aqui, usamos o operador sizeof para obter o tamanho das variáveis x e y. Como ambas são variáveis inteiras, o tamanho retornado é de 4 bytes.
(v) Precedência e associatividade do operador
Já vimos quase todos os operadores C ++ e sabemos que eles podem ser usados em expressões para realizar operações específicas. Mas as expressões que vimos nos exemplos são simples e diretas. No entanto, dependendo de nossos requisitos, as expressões tendem a se tornar cada vez mais complexas.
Essas expressões complexas terão mais de um operador e muitos operandos. Em tal situação, precisamos avaliar qual operador deve ser avaliado primeiro.
Por exemplo, considere a seguinte expressão.
x = 4 + 5/3;
Aqui temos operadores + e / e precisamos decidir qual expressão será avaliada primeiro. Em termos matemáticos, sabemos que a divisão será realizada antes da adição. Assim, a expressão se tornará x = 4 + (5/3) = 5.
Mas quando o compilador se depara com tal situação, também precisamos ter um mecanismo semelhante para decidir a ordem das operações, para que possa avaliar adequadamente a expressão.
Essa ordem na qual os operadores em uma expressão composta são avaliados é chamada de “Precedência” do operador. C ++ definiu precedência para todos os operadores e os operadores com maior precedência são avaliados primeiro.
O que acontece quando temos dois operadores lado a lado em uma expressão com a mesma precedência? É aqui que a associatividade de um operador entra em cena.
A associatividade diz ao compilador se deve avaliar uma expressão na sequência da esquerda para a direita ou da direita para a esquerda. Assim, usando a precedência e a associatividade de um operador, podemos avaliar efetivamente uma expressão e obter o resultado desejado.
C ++ fornece uma tabela que consiste em precedência e associatividade de vários operadores que usa.
Esta tabela é fornecida a seguir.
Precedência / Associatividade Operador Descrição 1 nenhum ::
:: Operador de resolução de escopo
(unário)
(binário) 2 L-> R ()
()
()
{}
modelo()
modelo{}
()
.
->
++
––
typeid
const_cast
dynamic_cast
reinterpret_cast
static_cast Parênteses
Chamada de função
Inicialização
Inicialização uniforme (C ++ 11)
Elenco funcional
Elenco funcional (C ++ 11)
Subscrito de matriz
Acesso de membro a partir do objeto
Acesso de membro a partir do objeto ptr
Pós-incremento
Pós-decremento
Informações de tipo de tempo de execução
Jogue fora const
Elenco verificado em tempo de execução
Lançar um tipo para outro elenco verificado em tempo de compilação 3 R-> L +
-
++
––
!
~
(modelo)
tamanho de
E
*
novo
novo()
excluir
excluir() Mais unário
Unário menos
Pré-incremento
Pré-decremento
NÃO Lógico
NÃO bit a bit
Elenco estilo C
Tamanho em bytes
Endereço de
Desreferência
Alocação de memória dinâmica
Alocação de matriz dinâmica
Exclusão de memória dinâmica
Exclusão de matriz dinâmica 4 L-> R -> *
. * Seletor de ponteiro de membro
Seletor de objeto membro 5 L-> R *
/
% Multiplicação
Divisão
Módulo 6 L-> R +
- Adição
Subtração 8 L-> R <
<=
>
> = Comparação menor que
Comparação menor ou igual
Comparação maior que
Comparação maior ou igual 9 L-> R !ERRO! carácter ilegal '!' Igualdade
Desigualdade 10 L-> R E E bit a bit 11 L-> R ^ XOR bit a bit 12 L-> R | OR bit a bit 13 L-> R && E lógico 14 L-> R || OR lógico 15 R-> L ?:
=
* =
/ =
% =
+ =
- =
<<=
>> =
& =
| =
^ = Condicional (veja a nota abaixo)
Atribuição
Atribuição de multiplicação
Atribuição de divisão
Atribuição de módulo
Atribuição de adição
Atribuição de subtração
Atribuição de deslocamento para a esquerda aos bits
Atribuição de deslocamento à direita bit a bit
Atribuição AND bit a bit
Atribuição OR bit a bit
Atribuição XOR bit a bit 16 R-> L lançar Jogue expressão 17 L-> R , Operador de vírgula
Notas:
- O nível de precedência 1 é o nível de precedência mais alto e o nível 17 é o mais baixo. Os operadores com um nível de precedência mais alto são avaliados primeiro.
- L-> R significa associatividade da esquerda para a direita.
- R-> L significa associatividade da direita para a esquerda.
Conclusão
Isso é tudo sobre os operadores em C ++.
Já discutimos quase todos os operadores. Alguns operadores específicos que estão presentes na tabela de precedência acima que não discutimos, serão discutidos de acordo com os tópicos que cobriremos em nossos próximos tutoriais.
=> Veja aqui para explorar a lista completa de tutoriais C ++
Leitura recomendada
- Exemplos de operadores booleanos e aritméticos do Unix Shell Script
- Operadores Python
- Novos / excluir operadores em C ++ com exemplos
- Tipos de dados Python
- Declarações condicionais Unix: If Then Else e Operadores relacionais
- Tutorial Python DateTime com exemplos
- Tutorial de injeção de HTML: tipos e prevenção com exemplos
- Cortar comando no Unix com exemplos
