gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

A few translations and some small changes (#33052)

Browse Source
This commit is contained in:
Flavia Schaller
2019-08-16 09:38:15 -03:00
committed by Tom
parent f78e98798e
commit b8bcdcb9af
1 changed files with 175 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

358
guide/portuguese/cplusplus/tokens-operators/index.md
View File

@ -1,186 +1,178 @@
--- ---
title: Operators title: Operators
localeTitle: Operadores localeTitle: Operadores
--- ---
# Operadores: # Operadores:
* Os operadores permitem que você execute operações em seus dados. * Os operadores permitem que você execute operações em seus dados.
* Os dados que estão sendo operados são chamados de _operando_ . * Os dados que estão sendo operados são chamados de _operandos_ .
* Os diferentes tipos de operadores em C ++ são: * Os diferentes tipos de operadores em C ++ são:
* _OPERANDS_ são os dados em que o operador executa determinados comandos. * _OPERANDOS_ são os dados em que o operador executa determinados comandos.
* Os operadores são de 3 tipos: unário (funciona em 1 operando), binário (trabalha em 2 operandos), ternário (trabalha em 3 operandos). * Os operadores são de 3 tipos: unário (funciona em 1 operando), binário (trabalha em 2 operandos), ternário (trabalha em 3 operandos).
### 1 Os operadores de I / O - ### 1 Os operadores de I / O -
* Esses operadores permitem direcionar entrada e saída. * Esses operadores permitem direcionar entrada e saída.
## Oerador de entrada ">>" ## ## Oerador de entrada ">>" ##
é usado para ler dados da entrada padrão (a instrução "cin"). é usado para ler dados da entrada padrão (a instrução "cin").
## O operador de saída "<<" ## O operador de saída "<<"
é usado para enviar saída na instrução `cout` . é usado para enviar saída na instrução `cout` .
### 2 Os operadores aritméticos - ### 2 Os operadores aritméticos -
* Esses operadores permitem que você execute operações aritméticas básicas. * Esses operadores permitem que você execute operações aritméticas básicas.
1. O operador `+` _adiciona_ os dois operandos. 1. O operador `+` _adiciona_ os dois operandos.
2. O operador `-` _subtrai_ os dois operandos. 2. O operador `-` _subtrai_ os dois operandos.
3. O operador `*` _multiplica_ os dois operandos. 3. O operador `*` _multiplica_ os dois operandos.
4. O operador `/` _divide_ e fornece o _quociente_ dos dois operandos. 4. O operador `/` _divide_ e fornece o _quociente_ dos dois operandos.
5. O operador `%` _divide_ e fornece o _restante_ dos dois operandos. (Ou, para o leitor mais matematicamente inclinado, `a % b` é essencialmente o resultado de "um mod b" 5. O operador `%` _divide_ e fornece o _restante_ dos dois operandos. (Ou, para o leitor mais matematicamente inclinado, `a % b` é essencialmente o resultado de "um mod b"
### Exemplo de uso de operadores aritméticos: ### Exemplo de uso de operadores aritméticos:
\`\` \`cpp ```cpp
#include <iostream>
using namespace std;
# incluir
int main()
usando namespace std; {
int a = 5; //1st operand
int main () { int a = 5; // 1º operando int b = 10; // 2º operando int b = 10; //2nd operand
```
cout << "+ operator " << a+b << "\n"; //Add cout << "+ operator " << a+b << "\n"; //Add
cout << "- operator " << ab << "\n"; //Subtract cout << "- operator " << a-b << "\n"; //Subtract
cout << "* operator " << a*b << "\n"; //Multiply cout << "* operator " << a*b << "\n"; //Multiply
cout << "/ operator " << b/a << "\n"; //Find Quotient cout << "/ operator " << b/a << "\n"; //Find Quotient
cout << "modulus operator " << b%a << "\n"; //Find remainder cout << "modulus operator " << b%a << "\n"; //Find remainder
return 0; return 0;
``` }
```
} \`\` \`
SAÍDA:
SAÍDA: ```
``` + operator 15
+ operator 15 - operator -5
- operator -5 * operator 50
* operator 50 / operator 2
/ operator 2 modulus operator 0
modulus operator 0 ```
```
[Experimente o código você mesmo! :)](https://repl.it/Mge9)
[Experimente o código você mesmo! :)](https://repl.it/Mge9)
### O operador de incremento:
### O operador de incremento:
* `++` é conhecido como o operador de incremento. Aumenta o valor de uma variável inteira em 1.
* `++` é conhecido como o operador de incremento. Aumenta o valor de uma variável inteira em 1.
Os 2 tipos de incremento:
Os 2 tipos de incremento:
* O pré-incremento primeiro incrementa o valor e depois o utiliza. Exemplo: `int a ; ++a;`
* O pré-incremento primeiro incrementa o valor e depois o utiliza. Exemplo: `int a ; ++a;` * O pós-incremento primeiro usa a variável para em seguida, incrementá-la. Exemplo: `int b; b++;`
* Post increment primeiro usa a variável, em seguida, incrementa-lo. Exemplo: `int b; b++;`
### O operador de decremento:
### O operador de decremento:
* `--` é conhecido como o operador de decremento. Diminui o valor de uma variável inteira por 1.
* `--` é conhecido como o operador de decréscimo. Diminui o valor de uma variável inteira por 1.
Os 2 tipos de decremento:
Os 2 tipos de decréscimo:
* Pré-decremento primeiro decrementa o valor, para em seguida usá-lo. Exemplo: `int a ; --a;`
* Pre decrement primeiro decrementa o valor e, em seguida, usa-o. Exemplo: `int a ; --a;` * Pós-decremento primeiro usa a variável e em seguida, a diminui. Exemplo: `int b; b--;`
* Post decrement primeiro usa a variável, em seguida, diminui. Exemplo: `int b; b--;`
Exemplo de operadores de incremento e decremento:
Exemplo de operadores de incremento e decremento:
```cpp
```cpp #include <iostream>
#include <iostream> using namespace std;
using namespace std;
int main()
int main() {
{ int a = 5; //1st operand
int a = 3 ,b = 4; int b = 10; //2nd operand
// INCREMENT cout << "+ operator " << a+b << "\n"; //Add
cout<< "Value of int a PRE INCREMENTED : " << ++a << "\n"; cout << "- operator " << a-b << "\n"; //Subtract
cout<< "Value of int b POST INCREMENTED : " << b++ << "\n"; cout << "* operator " << a*b << "\n"; //Multiply
cout<< "Value of b is changed after using once : " << b << "\n"; cout << "/ operator " << b/a << "\n"; //Find Quotient
cout << "modulus operator " << b%a << "\n"; //Find remainder
// DECREMENT
cout << "\n"; //go to next line return 0;
a = 10; //Assigning a new value to a }
b = 10; //Assigning a new value to b ```
cout << "Value of int a PRE DECREMENTED : " << --a << "\n";
cout << "Value of int b POST DECREMENTED : " << b-- << "\n"; OUTPUT :
cout << "Value of b is changed after using once : " << b << "\n"; ```cpp
+ operator 15
return 0; - operator -5
} * operator 50
``` / operator 2
modulus operator 0
SAÍDA: ```
```
Value of int a PRE INCREMENTED : 4 [Experimente o código você mesmo! :)](https://repl.it/Mgg4/2)
Value of int b POST INCREMENTED : 4
Value of b is changed after using once : 5 ### 3: Operadores Relacionais:
Value of int a PRE DECREMENTED : 9 * Esses operadores nos dizem a relação entre dois operandos e retornam um valor booleano (0 ou 1). Se a relação é `true` (verdadeira) então resultará em 1. Se a relação for `false` (falsa), resultará em 0.
Value of int b POST DECREMENTED : 10
Value of b is changed after using once : 9 * Os 6 operadores relacionais são:
```
1. Menor que `<`
[Experimente o código você mesmo! :)](https://repl.it/Mgg4/2) 2. Maior do que `>`
3. Menor ou igual a `<=`
### 3: Operadores Relacionais: 4. Maior que ou igual a `>=`
5. Igual a `==`
* Esses operadores nos dizem a relação entre dois operandos e retornam um valor booleano (0 ou 1). Se a relação é `true` então resulta em 1. Se a realção for falsa, isso resultará em 0. 6. Não é igual a `!=`
* Os 6 operadores relacionais são: ### 4: Operadores Lógicos:
1. Menos que `<` * Esses operadores combinam expressões para operações lógicas. Eles são :
2. Maior do que `>`
3. Menor ou igual a `<=` 1. Lógico E `&&` : Avalia para verdadeiro se ambos os valores forem verdadeiros.
4. Maior que ou igual a `>=`
5. Igual a `==` 2. Lógica OU `||` : Avalia como verdadeiro se algum valor for verdadeiro.
6. Não é igual a `!=`
3. Lógico NÃO `!` : Se a _expressão_ for verdadeira, então _! A expressão_ é falsa. Este operador inverte o valor e é um operador unário.
### 4: Operadores Lógicos:
### 5\. Operadores Ternários:
* Esses operadores combinam expressões para operações lógicas. Eles são :
O operador `?:` É o operador ternário, ou o _operador condicional_ , porque ele pode ser usado para substituir uma instrução `if else` , ou mesmo uma declaração `if else if` . A sintaxe:
1. Lógico E `&&` : Avalia para verdadeiro se ambos os valores forem verdadeiros.
2. Lógica OR `||` : Avalia como verdadeiro se algum valor for verdadeiro. `condition ? ValueIfTrue : ValueIfFalse` . Isso se expande para:
3. Lógico NÃO `!` : Se a _expressão_ for verdadeira, então _! A expressão_ é falsa. Este operador inverte o valor verdade e é um operador unário. ```cpp
if(condition)
### 5\. Operadores Ternarios: ValueIfTrue;
else ValueIfFalse;
O operador `?:` É o operador ternário, ou o _operador condicional_ , porque ele pode ser usado para substituir uma instrução `if else` , ou mesmo uma declaração `if else if` . A sintaxe: ```
Chamar `ValueIfTrue` um valor é um pouco errado, já que não precisa ser um número. Algo assim:
`condition ? ValueIfTrue : ValueIfFalse` . Isso se expande para:
`condition ? FirstLevelTrueValue : ConditionIfFalse ? SecondLevelTrueValue : SecondLevelFalseValue` também funciona e é interpretado da seguinte maneira `if else if` :
```cpp
if(condition) ```cpp
ValueIfTrue; if(condition)
else ValueIfFalse; FirstLevelTrueValue;
``` else if(ConditionIfFalse)
SecondLevelTrueValue;
Chamar `ValueIfTrue` um valor é um pouco errado, já que não precisa ser um número. Algo assim: else SecondLevelFalseValue;
```
`condition ? FirstLevelTrueValue : ConditionIfFalse ? SecondLevelTrueValue : SecondLevelFalseValue` também funciona e é interpretado da seguinte maneira `if else if` :
Da mesma forma, instruções `if` aninhadas também podem ser feitas usando operadores ternários.
```cpp
if(condition) _Camper, agora você sabe quais são os tokens. _ _PARABÉNS_
FirstLevelTrueValue;
else if(ConditionIfFalse) **Boa sorte para todos vocês**
SecondLevelTrueValue;
else SecondLevelFalseValue; **Codificação Feliz! :)**
```
**Sinta-se à vontade para fazer qualquer pergunta sobre a página GitHub do [FreeCodeCamp](https://forum.freecodecamp.org/) ou [sobre o Fórum do FreeCodeCamp.](https://forum.freecodecamp.org/)**
Da mesma forma, instruções `if` aninhadas também podem ser feitas usando operadores ternários.
_Camper, agora você sabe quais são as fichas. O próximo artigo será sobre_ _PARABÉNS_
**Boa sorte para todos vocês**
**Codificação Feliz! :)**