Operadores em C++

1. Operadores comuns fornecidos em linguagem C++
2. Operações sobrecarregadas em C++

Este artigo demonstrará vários métodos sobre como usar operadores em C++.

Operadores comuns fornecidos em linguagem C++

Os operadores são a parte essencial das expressões na programação C++. Eles fornecem diferentes operações conduzidas em operandos fornecidos, e os resultados avaliados são geralmente utilizados pelo programador conforme necessário. Podemos dividir livremente os operandos em dois tipos: operadores comuns e especiais. Operadores comuns são operações implementadas quase universalmente na maioria das linguagens de programação e incluem aritmética, lógica, comparação, atribuição, operadores de acesso de membro e vários outros.

Semelhante às regras da álgebra, existem características de precedência e associatividade quando vários operadores formam a expressão. Resumiremos algumas dessas regras neste artigo, mas a descrição completa deve ser consultada na documentação do idioma e no operador tabela de precedência. Observe que as regras de precedência e associatividade para operações aritméticas básicas são semelhantes às regras matemáticas comuns. Assim, as expressões no exemplo a seguir geram os inteiros 20 e 10 em vez de 60 e 30.

#include <iostream>

using std::cout;
using std::endl;

int main() {
  cout << 10 + 2 * 5 << endl;
  cout << 40 - 20 - 10 << endl;

  return EXIT_SUCCESS;
}

Resultado:

20 10

O programador pode usar parênteses para substituir as regras gerais de precedência e associatividade, da mesma forma que na álgebra. Cada expressão composta entre parênteses será tratada como uma unidade que é avaliada separadamente. Um dos erros comuns ao usar a aritmética de ponteiro é perder os parênteses.

Se acessarmos o elemento na matriz usando a aritmética de ponteiro mais a operação de desreferência, precisamos colocar a aritmética entre parênteses. Caso contrário, o valor apontado pelo ponteiro fornecido seria incrementado pelo operando numérico e não pelo ponteiro em si, porque o operador de desreferência tem precedência mais alta do que a adição.

#include <iostream>

using std::cout;
using std::endl;

int main() {
  int vec[] = {10, 22, 63, 14};
  cout << *vec + 2 << endl;
  cout << *(vec + 2) << endl;

  return EXIT_SUCCESS;
}

Resultado:

12 63

Operações sobrecarregadas em C++

Um dos recursos mais poderosos que podemos encontrar na linguagem C++ é que ela permite ao programador definir como os operadores devem se comportar quando chamados em objetos definidos pelo usuário, como classes. Como esse recurso fornece operações alternativas para o operador fornecido, é chamado de operadores sobrecarregados. No entanto, observe que o número de operandos e a precedência não podem ser modificados pela implementação de um operador sobrecarregado.

O fragmento de código a seguir declara uma classe Person que contém dois membros de dados de string e sobrecarrega o operador + para este tipo. Operadores sobrecarregados são implementados de maneira semelhante a outras funções de classe com nomes especiais, começando com a palavra-chave operator seguida pelo próprio símbolo do operador. Essas funções podem ter um tipo de retorno e uma lista de parâmetros. Lembre-se de que uma das restrições da sobrecarga do operador é que o programador não pode criar novos operadores como $> ou !!.

#include <iostream>
#include <string>
#include <utility>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

class Person {
 public:
  Person(string s1, string s2) : name(std::move(s1)), surname(std::move(s2)) {}

  Person operator+(const Person &p) {
    Person ret(name + p.name, surname + p.surname);
    return ret;
  }

  void printPerson() { cout << name << " " << surname << endl; }

 private:
  string name;
  string surname;
};

int main() {
  Person P1("Buddy", "Rich");
  Person P2("Lady", "Bee");
  P1 = P1 + P2;

  P1.printPerson();

  exit(EXIT_SUCCESS);
}

Resultado:

BuddyLady RichBee