Olá, meu nome é Lucas Turos e estou aqui para te ajudar a dar os primeiros passos no C++, uma das linguagens mais poderosas e versáteis da programação! Neste artigo, você aprenderá a criar seu primeiro programa “Hello World”, configurar seu ambiente de desenvolvimento, e explorar ferramentas e conceitos essenciais. Desde a história do C++ até a aplicação de conceitos matemáticos, esse guia cobre tudo o que você precisa para começar.

Índice

• 1. Introdução
  • 1.1. Uma breve história
  • 1.2. Características da linguagem
• 2. Ambiente de Desenvolvimento
  • 2.1. Configuração
  • 2.2. Primeiro Programa: Hello World
• 3. Ferramentas e Recursos na Programação em C++
  • 3.1. Ferramentas de Análise e Formatação de Código
  • 3.2. Bibliotecas Padrões do C++
  • 3.3. Criação de Bibliotecas Personalizadas
  • 3.4. Interoperabilidade com o C
• 4. Conceitos Básicos de Programação em C++
  • 4.1. Tipos de dados
  • 4.2. Operadores
  • 4.3. Estruturas de Controle
• 5. Funções, Procedimentos e Funções Lambda
  • 5.1. Funções
  • 5.2. Procedimentos
  • 5.3. Função Lambda
• 6. Guia de Estudos para Programadores Iniciantes
• 7. Conceitos Matemáticos na Programação
  • 7.1. Aplicação de Conceitos de Álgebra e Geometria
• 8. Exercícios Práticos e Desafios
• 9. Conclusão
• 10. Referências

1. Introdução

Nesta seção, exploraremos a linguagem C++, abordando sua origem, evolução e características principais. Primeiro, será abordado um pouco da história do C++, desde sua criação até as versões mais recentes. Na sequência, discutiremos as características da linguagem.

1.1. Uma Breve História

O C++ é uma linguagem de programação de alto nível, fortemente tipada e de propósito geral. Criada pelo cientista da computação Bjarne Stroustrup em meados de 1983 no Bell Labs, o C++ foi desenvolvido como uma extensão da linguagem C, introduzindo conceitos de programação orientada a objetos (OOP) e outras funcionalidades avançadas desse paradigma, como funções virtuais, sobrecarga de operadores, herança múltipla, tratamento de exceções, e outras funções como templates. Inicialmente, a linguagem foi denominada C with Classes (C com classes, em português). Já seu nome “C++” foi posteriormente sugerido por Rick Mascitti, em referência ao operador ”++”, simbolizando a ideia de uma evolução do C.

Desde sua criação a linguagem evoluiu bastante, sendo padronizada pela ISO/IEC 14882:1998, e uma correção na sequência em 2003. No entanto, foi em 2011 que uma versão mais acessível, o C++11, foi lançada, o que popularizou ainda mais a linguagem. Essa versão tornou o desenvolvimento mais simplificado que por consequência melhorou seu aprendizado, tornando-se amplamente adotada no ensino formal e informal para gerar novos programadores. Atualmente, o C++ está na versão C++23, com a próxima versão, conhecida informalmente como C++26, já em desenvolvimento.

Com essa trajetória, o C++ consolidou-se como uma linguagem relevante e importante no desenvolvimento de software de alta performance, sendo aplicada em sistemas operacionais, jogos, motores gráficos, navegadores web e aplicações em tempo real, como sistemas embarcados. Sua versatilidade e controle sobre os recursos do sistema fazem do C++ uma escolha preferida em áreas como desenvolvimento de sistemas, finanças e automação.

1.2. Características da Linguagem

O C++ é uma linguagem de propósito geral que combina a programação orientada a objetos com a programação procedural. Essa combinação oferece ao programador uma maior flexibilidade, permitindo a escolha do paradigma mais adequado ao projeto e possibilitando a criação de códigos mais eficientes e reutilizáveis, graças à modularização. Além disso, o C++ suporta a programação genérica por meio de templates, o que permite a criação de códigos que funcionam com qualquer tipo de dado, sem a necessidade de reescrever a lógica para diferentes tipos.

2. Ambiente de Desenvolvimento

Para começar, é necessário configurar um ambiente de desenvolvimento. Isso inclui a escolha e instalação de um compilador, como GCC/G++, Clang e/ou MSVC, além de um editor de texto ou IDE para a escrita do programa.

2.1. Configuração

O primeiro passo é instalar e testar o compilador escolhido. Por exemplo, para verificar se o compilador g++ está corretamente instalado, é necessário executar o comando g++ --version no terminal. Se tudo estiver configurado corretamente, a versão do compilador e algumas informações adicionais serão exibidas.

Além do compilador, a escolha do editor de texto ou IDE é uma tarefa difícil, pois há várias opções disponíveis e vai do gosto qual atende mais. Alguns dos editores de texto mais utilizados são Visual Studio Code, Vim, NeoVim e Notepad++. As IDEs, por sua vez, oferecem um ambiente mais integrado, onde muitas vezes não é necessária a instalação de ferramentas adicionais diretamente no sistema. Algumas das IDEs disponíveis são Visual Studio, Dev-C++, CLion, Qt Creator, entre outras.

Para esta aula, recomenda-se o uso do Visual Studio Code. Ele é um editor de texto configurável, que pode ser transformado em uma IDE completa com todas as ferramentas necessárias. Siga as orientações de instalação disponíveis no site da Microsoft. Será necessário instalar apenas uma extensão: o Clangd, da LLVM. Além disso, é preciso instalar o Clangd no sistema.

2.2. Primeiro Programa: Hello World

Após realizar todas as configurações, é necessário testar o ambiente. É sempre recomendável começar com um programa simples para garantir que tudo está correto. Um exemplo clássico para esse propósito é o “Hello, World!”.

A estrutura do programa começa com a inclusão de bibliotecas, como a <iostream>, que é necessária para operações de entrada e saída. Em seguida, é implementada a função int main(), que concentra toda a rotina do programa. Dentro dessa função, utiliza-se std::cout para exibir “Hello, World!” no terminal.

#include <iostream>

int main() {
    std::cout << "Hello, World!\n";
    return 0;
}

No código acima, foram introduzidos novos termos. O #include é utilizado para incluir ou chamar uma biblioteca padrão ou uma biblioteca desenvolvida pelo próprio programador. Já o return seguido de zero indica o término da rotina.

Após escrever o programa, é necessário salvar o arquivo com um nome de sua escolha (por exemplo, hello) e a extensão .cpp. Em seguida, o programa deve ser compilado utilizando o seguinte comando:

g++ -o hello hello.cpp

Aqui, g++ é o compilador, e -o hello especifica o nome do executável. A flag -o indica output (saída), e, finalmente, hello.cpp é o arquivo que contém o código.

Para executar o programa, basta digitar: ./hello.

Se estiver no Windows, o executável terá a extensão .exe.

3. Ferramentas e Recursos na Programação em C++

No desenvolvimento em C++, há uma ampla variedade de ferramentas e bibliotecas disponíveis que podem melhorar significativamente a eficiência e a qualidade do código.

3.1. Ferramentas de Análise e Formatação de Código

Para melhorar a legibilidade e a manutenção do código, é essencial utilizar ferramentas especializadas como Clangd, clang-tidy e clang-format, que fazem parte do conjunto de ferramentas da LLVM.

O Clangd oferece um suporte que engloba o autocompletar código e detectar erros em tempo real dentro dos editores de texto. O clang-tidy ajuda na análise estática do código, identificando possíveis erros e práticas de codificação inadequadas. Já o clang-format automatiza a formatação do código, garantindo consistência no estilo de escrita.

3.2. Bibliotecas Padrões do C++

Uma das maiores vantagens do C++ é a sua grande coleção de bibliotecas padrão, que fornecem soluções eficientes para problemas comuns de programação. A Standard Template Library (STL), oferece uma variedade de estruturas de dados, como vetores (arrays dinâmicos), listas e filas, além de algoritmos prontos para busca, ordenação e manipulação de dados. Outras bibliotecas padrão como iostream, que facilita operações de entrada e saída, e algorithm, que oferece algoritmos otimizados para manipulação de dados, são amplamente utilizadas em diversos tipos de aplicações.

3.3. Criação de Bibliotecas Personalizadas

Além de utilizar bibliotecas padrão, os desenvolvedores podem criar suas próprias bibliotecas para reutilizar código em diferentes projetos. Criar uma biblioteca personalizada permite encapsular funções, classes e estruturas de dados que podem ser compartilhadas e mantidas de forma centralizada, facilitando o desenvolvimento de projetos maiores e mais complexos.

A criação de bibliotecas envolve a organização do código em arquivos de cabeçalho (.h ou .hpp) e arquivos de implementação (.cpp), permitindo a modularização e o encapsulamento de funcionalidades específicas. Isso não apenas promove a reutilização do código, mas também melhora a manutenção e a escalabilidade do software.

3.4. Interoperabilidade com o C

O C++ também é conhecido por sua interoperabilidade com a linguagem C, permitindo que funções e bibliotecas escritas em C sejam facilmente integradas em programas C++. Isso é particularmente útil quando se trabalha em sistemas legados ou quando se deseja aproveitar o vasto conjunto de bibliotecas disponíveis em C.

4. Conceitos Básicos de Programação em C++

Ao compreender a estrutura básica de um programa, é essencial aprofundar-se nos conceitos fundamentais da linguagem, como tipos de dados, operadores e estruturas de controle.

4.1. Tipos de dados

O C++ é uma linguagem fortemente tipada, o que significa que é necessário especificar o tipo da variável ao declará-la. Os tipos primitivos são:

• int: números inteiros;
• char: caracteres ASCII (‘A’, ‘a’, etc.);
• double: números de ponto flutuante de dupla precisão;
• float: números de ponto flutuante; e
• bool: tipo binário, que aceita apenas os valores true (verdadeiro) e false (falso), correspondendo aos estados binários 0 (falso ou desligado) e 1 (verdadeiro ou ligado).

A seguir, é demonstrado um exemplo de código com diferentes tipos de declarações.

#include <iostream>

int main() {
    int inteiro = 10;
    char caractere = 'A';
    double num1ponto5 = 1.5;
    float num1ponto5f = 1.5f;
    bool condicao = true;

    std::cout << "Inteiro: " << inteiro << '\n'
              << "Caractere: " << caractere << '\n'
              << "Double: " << num1ponto5 << '\n'
              << "Float: " << num1ponto5f << '\n';

    if (condicao == true) {
        // Exibe o valor de condicao usando std::boolalpha para mostrar
        // true/false em vez de 1/0
        std::cout << std::boolalpha << condicao << '\n';
        condicao = false;
    }
    if (condicao == false) {
        std::cout << std::boolalpha << condicao << '\n';
    }

    // Saída:
    // Inteiro: 10
    // Caractere: A
    // Double: 1.5
    // Float: 1.5
    // true
    // false

    return 0;
}

4.2. Operadores

A linguagem C++ também oferece diversos tipos de operadores, incluindo operadores aritméticos, de atribuição, relacionais e lógicos, entre outros. A seguir, estão listados os principais operadores:

• Aritméticos: +, -, *, /, %;
• Atribuição: =, +=, -=, *=, /=;
• Relacionais: ==, !=, <=, >=, <, >; e
• Lógicos: &&, ||, !.

No código presente na subseção 4.1, é demonstrado exemplos de uso do operador relacional ==, do operador de atribuição =, e do operador de fluxo <<. Em seguida, são apresentados exemplos que ilustram a aplicação de outros operadores.

int main() {
    // Operadores aritméticos
    int soma = 10 + 2;             // Soma: 12
    int subtracao = 4 - 2;         // Subtração: 2
    int multiplicacao = 4 * 4;     // Multiplicação: 16
    double divisao = 1.0 / 2.0;    // Divisão: 0.5

    // Operadores de atribuição
    int valor = 5;
    valor += 3; // Valor de 5 agora é 8
    valor -= 2; // Valor de 8 agora é 6

    // Operadore relacional
    bool resultadoRelacional = (valor == 6); // True

    // Operadores lógicos
    bool resultadoLogico = (valor > 4) && (valor < 10); // True

    return 0;
}

4.3. Estruturas de Controle

As estruturas de controle em C++ fornecem blocos de condição, como if, else, e else if, além de blocos de repetição, como for, while, e do-while. As estruturas condicionais são utilizadas para tomar decisões lógicas, como comparar o tamanho de variáveis ou avaliar expressões binárias. Já os blocos de repetição, também conhecidos como loops, são empregados para manipular dados, seja em pequena ou grande escala. Eles são amplamente utilizados em operações de varredura de tipos de dados, como vetores, matrizes e strings (combinações de caracteres), bem como em operações matemáticas, como vetores, matrizes, séries infinitas, somatórios, produtórios, entre outras.

No código da subseção 4.1 demonstra o uso do bloco condicional if. Na sequência é demonstrado alguns exemplos de uso das estruturas de controle.

int main() {
    // Estruturas Condicionais

    // Exemplo de if
    int idade = 18;
    if (idade >= 18) {
        // Saída esperada: "Você é maior de idade."
    }

    // Exemplo de if-else
    idade = 16;
    if (idade >= 18) {
        // Saída esperada: "Você é maior de idade."
    } else {
        // Saída esperada: "Você é menor de idade."
    }

    // Exemplo de if-else if-else
    int nota = 75;
    if (nota >= 90) {
        // Saída esperada: "Nota: A"
    } else if (nota >= 80) {
        // Saída esperada: "Nota: B"
    } else if (nota >= 70) {
        // Saída esperada: "Nota: C"
    } else {
        // Saída esperada: "Nota: D"
    }

    // Estruturas de Repetição

    // Exemplo de for
    for (int i = 0; i < 5; ++i) {
        // Saída esperada: 0 1 2 3 4 (em uma linha)
    }

    // Exemplo de while
    int i = 0;
    while (i < 5) {
        // Saída esperada: 0 1 2 3 4 (em uma linha)
        ++i;
    }

    // Exemplo de do-while
    i = 0;
    do {
        // Saída esperada: 0 1 2 3 4 (em uma linha)
        ++i;
    } while (i < 5);

    return 0;
}

5. Funções, Procedimentos e Funções Lambda

Nesta seção, exploraremos três conceitos essenciais para a modularização e a reutilização de código em C++: funções, procedimentos e funções lambda. A compreensão desses conceitos permite a criação de programas mais organizados, flexíveis e eficientes.

5.1. Funções

As funções em C++ são blocos de código que realizam uma tarefa específica e podem retornar um valor. Elas são definidas fora da função main e podem ser chamadas a qualquer momento, melhorando a organização e a legibilidade do código. A estrutura básica de uma função em C++ inclui a declaração do tipo de retorno, o nome da função, os parâmetros de entrada (se houver), e o corpo da função. Segue abaixo um exemplo de função.

// Exemplo de função que soma dois números inteiros e retorna o resultado
int soma(int a, int b) { return a + b; }

// Dentro do main
int resultado = soma(3, 4);
// Saída: 7

5.2. Procedimentos

Procedimentos são funções que não retornam valor, ou seja, têm o tipo de retorno void. Eles são usados quando a execução de uma série de instruções é necessária, mas não é preciso retornar um valor. A seguir um exemplo de procedimento.

// Exemplo de procedimento que exibe uma mensagem
void exibirMensagem() {
    std::cout << "Olá, Programador!\n";
}

// Dentro do main
exibirMensagem();
// Saída: Olá, Programador!

5.3. Função Lambda

As funções lambda foram introduzidas no C++11 e permitem a criação de funções anônimas diretamente dentro de expressões. Elas são úteis para operações rápidas, como passar funções como argumentos para algoritmos. Logo abaixo, um exemplo de função Lambda.

1 // Exemplo de função lambda que multiplica dois números
2 auto multiplicar = [](int x, int y) { return x * y; };
3
4 // Dentro do main
5 int produto = multiplicar(3, 4);
6 // Saída: 12

6. Guia de Estudos para Programadores Iniciantes

Iniciar uma jornada na programação exige uma base sólida e bem estruturada, que aborde todos os conceitos necessários para desenvolver suas habilidades de forma eficaz. Independentemente da linguagem escolhida, como o C++, é crucial dominar temas como lógica de programação, algoritmos, estruturas de dados e programação orientada a objetos. Esses conceitos não apenas são fundamentais para o C++, mas também se aplicam a diversas outras linguagens de programação. A seguir, é apresentado uma lista organizada por ordem de relevância e complexidade. É importante seguir essa sequência, pois ela começa com os conceitos mais básicos e acessíveis, progredindo para temas mais complexos:

• Lógica de programação e algoritmo: A lógica de programação é a base de todo desenvolvimento, pois envolve o pensamento estruturado e a capacidade de resolver problemas por meio de etapas lógicas. Algoritmos, por sua vez, são sequências de instruções destinadas a solucionar problemas específicos. A combinação desses conceitos permite a criação de soluções nas quais o desenvolvedor utiliza sua lógica para definir a sequência de passos necessários à resolução do problema.
• Estrutura de dados: Essencial para a organização e manipulação eficiente de informações, as estruturas de dados abrangem conceitos como vetores (arrays), listas, filas, pilhas e árvores. Embora algumas linguagens utilizem classes para implementar essas estruturas, em C++ é possível utilizar tanto structs quanto classes.
• Programação orientada a objetos (OOP): Um paradigma que permite organizar o código de forma modular e reutilizável, a OOP introduz conceitos como classes, objetos, herança, encapsulamento e polimorfismo. Estes conceitos são fundamentais para o desenvolvimento de aplicações mais complexas e escaláveis.

7. Conceitos Matemáticos na Programação

A matemática desempenha um papel fundamental no desenvolvimento de software, especialmente em áreas como ciência de dados, simulações, computação gráfica e inteligência artificial. No C++, operações matemáticas básicas, como adição, subtração, multiplicação e divisão, são frequentemente implementadas para manipulação de dados, abrangendo desde números até caracteres. Além disso, a manipulação de números inclui a conversão entre diferentes tipos numéricos e a geração de números aleatórios, processos fundamentais para uma ampla gama de aplicações.

7.1. Aplicação de Conceitos de Álgebra e Geometria

Além das operações matemáticas básicas, conceitos mais avançados, como álgebra linear e geometria computacional, são frequentemente aplicados em C++ ou em outras linguagens. Esses conceitos são utilizados tanto em seu sentido literal, como no cálculo do produto escalar de vetores ou na determinação da distância entre dois pontos em um espaço bidimensional ou tridimensional.

Além dessas aplicações diretas, o uso de conceitos matemáticos como séries e somatórios na programação é importante para a manipulação de vetores e matrizes. Nas linguagens de programação, esses conceitos são aplicados para acessar, percorrer e modificar dados estruturados. Por exemplo, ao trabalhar com grandes volumes de dados, como em simulações ou processamento de imagens, a compreensão da lógica de somatórios permite que o programador percorra matrizes ou vetores de forma eficiente, reduzindo o tempo de execução e melhorando o desempenho geral do software.

Esses conceitos matemáticos são relevantes e importantes em áreas como desenvolvimento de jogos, simulações físicas e computação gráfica, onde a precisão e a eficiência no controle de dados. A compreensão de como a álgebra linear e a lógica de somatórios podem ser aplicadas ao acesso e manipulação de vetores e matrizes torna-se, portanto, uma ferramenta poderosa na criação de sistemas de alta performance e na solução de problemas computacionais complexos.

A seguir é demonstrado um exemplo básico para demonstrar esses conceitos onde é desenhado um círculo, um triângulo e um quadrado no terminal.

#include <iostream>
#include <vector>

// Definindo o tamanho da grade
const int largura = 41;
const int altura = 11;

// Função para desenhar um círculo na grade
void desenhaCirculo(int cx, int cy, int raio,
                    std::vector<std::vector<char>> &grade) {
    // Itera sobre cada ponto na área que pode conter o círculo
    for (int y = cy - raio; y <= cy + raio; ++y) {
        // Verifica se o ponto está dentro dos limites da grade
        if (y < 0 || y >= altura)
            continue;
        for (int x = cx - raio; x <= cx + raio; ++x) {
            // Verifica se o ponto está dentro dos limites da grade
            if (x < 0 || x >= largura)
                continue;
            // Calcula a distância do ponto (x, y) ao centro (cx, cy)
            int dx = x - cx;
            int dy = y - cy;
            // Verifica se o ponto está dentro do círculo
            if ((dx * dx + dy * dy) <= (raio * raio)) {
                grade[y][x] = '*'; // Marca o ponto na grade
            }
        }
    }
}

// Função para desenhar um quadrado na grade
void desenhaQuadrado(int x0, int y0, int lado,
                     std::vector<std::vector<char>> &grade) {
    // Itera sobre cada linha do quadrado
    for (int y = y0; y < y0 + lado; ++y) {
        // Verifica se a linha está dentro dos limites da grade
        if (y < 0 || y >= altura)
            continue;
        // Itera sobre cada coluna do quadrado
        for (int x = x0; x < x0 + lado; ++x) {
            // Verifica se a coluna está dentro dos limites da grade
            if (x < 0 || x >= largura)
                continue;
            grade[y][x] = '*';
        }
    }
}

// Função para desenhar um triângulo na grade
void desenhaTriangulo(int x0, int y0, int alturaTriangulo,
                      std::vector<std::vector<char>> &grade) {
    // Itera sobre cada linha do triângulo
    for (int y = 0; y < alturaTriangulo; ++y) {
        // Verifica se a linha está dentro dos limites da grade
        if (y0 + y < 0 || y0 + y >= altura)
            continue;
        // Itera sobre as colunas para formar a base do triângulo
        for (int x = -y; x <= y; ++x) {
            // Verifica se a coluna está dentro dos limites da grade
            if (x0 + x < 0 || x0 + x >= largura)
                continue;
            grade[y0 + y][x0 + x] = '*';
        }
    }
}

int main() {
    const int raio = 4;            // Define o raio do círculo
    const int ladoQuadrado = 7;    // Define o lado do quadrado
    const int alturaTriangulo = 7; // Define a altura do triângulo

    // Inicializa a grade com espaços em branco usando vetor de vetores
    std::vector<std::vector<char>> grade(altura,
                                         std::vector<char>(largura, ' '));

    // Calcula a coordenada X do centro da grade
    const int centroX = largura / 2;
    // Calcula a coordenada Y do centro da grade
    const int centroY = altura / 2;

    // Desenha o quadrado à esquerda
    desenhaQuadrado(5, centroY - ladoQuadrado / 2, ladoQuadrado, grade);

    // Desenha o círculo no centro
    desenhaCirculo(centroX, centroY, raio, grade);

    // Desenha o triângulo à direita
    desenhaTriangulo(largura - 8, centroY - alturaTriangulo / 2,
                     alturaTriangulo, grade);

    // Imprime a grade com as formas geometricas
    for (int y = 0; y < altura; ++y) {
        for (int x = 0; x < largura; ++x) {
            std::cout << grade[y][x];
        }
        std::cout << '\n';
    }

    return 0;
}

// Saída:
//                 *
//  *******      *****          *
//  *******     *******        ***
//  *******     *******       *****
//  *******    *********     *******
//  *******     *******     *********
//  *******     *******    ***********
//  *******      *****    *************
//                 *

8. Exercícios Práticos e Desafios

Para consolidar o aprendizado, é essencial praticar constantemente e buscar inspiração na internet, explorando repositórios ou aplicando ideias próprias. Na aba Desafios do site oferece uma série de desafios focados em problemas recorrentes na ciência da computação. Além disso, no site da “Python Brasil”, é possível encontrar diversos exercícios para praticar lógica de programação, estruturas de dados e programação orientada a objetos

9. Conclusão

Ao concluir este artigo, você já deve ter adquirido uma boa compreensão dos conceitos básicos de C++, desde a configuração do ambiente de desenvolvimento até uma visão geral da aplicação da matemática na programação. Para aprofundar seus estudos, recomenda-se explorar recursos como as documentações disponíveis nos sites cplusplus.com, cppreference.com e learn.microsoft.com são excelentes para expandir seu conhecimento. Se ainda restarem dúvidas sobre os tópicos abordados, participar de grupos de estudo ou comunidades de programadores, como o grupo no Telegram “Os Programadores”, pode ser uma excelente oportunidade para discutir questões e compartilhar experiências com outros desenvolvedores.

10. Referências

1. C++. Wikipédia, 2023 Disponível em https://pt.wikipedia.org/wiki/C%2B%2B. Acesso em: 22 de agosto de 2024.
2. MUFATTO, Gabriel Vinicius. C++ - A evolução do C. Unicentro, 2023. Disponível em: https://www3.unicentro.br/petfisica/2023/07/28/c-a-evolucao-do-c/. Acesso em: 22 de agosto de 2024.
3. O QUE é a linguagem de programação C++?. ICTEA. Disponível em: https://www.ictea.com/cs/index.php?rp=%2Fknowledgebase%2F8858%2FiQue-es-el-lenguaje-de-programacion-Cplusplus.html&language=portuguese-pt. Acesso em: 22 de agosto de 2024.
4. OPERADORES em C e C++. Wikipédia, 2020. Disponível em: https://pt.wikipedia.org/wiki/Operadores_em_C_e_C%2B%2B. Acesso em: 22 de agosto de 2024.