Linguagem C+ Um pequeno guia

### Capítulo 1: Introdução à Programação em C++

#### 1.1 O que é C++?

C++ é uma linguagem de programação de propósito geral, conhecida por sua eficiência e capacidade de suportar tanto a programação de alto nível quanto a de baixo nível. Foi criada por Bjarne Stroustrup, como uma extensão da linguagem C, adicionando características de programação orientada a objetos.

#### 1.2 História do C++

C++ surgiu no início dos anos 1980 como "C com Classes", uma extensão do C. Em 1983, o nome foi alterado para C++, refletindo o incremento das capacidades da linguagem (o operador `++` em C é usado para incrementar valores).

#### 1.3 Instalação e Configuração

Para começar a programar em C++, você precisa de um compilador e um editor de texto. Algumas opções populares incluem:

- **Compiladores**: gcc (gnu compiler collection), clang, msvc (microsoft visual c++)
- **ide's (ambientes de desenvolvimento integrados)**: visual studio, code::blocks, clion

##### instalando o gcc no windows

1. **Baixe o MinGW** (Minimalist GNU for Windows) de [mingw-w64.org](https://mingw-w64.org).
2. **Instale o MinGW** seguindo as instruções, assegurando-se de adicionar o caminho `bin` do MinGW à variável de ambiente `PATH`.

##### Instalando o GCC no Linux

1. **Abra o terminal**.
2. **Execute o comando**:
  ```bash
  sudo apt-get update
  sudo apt-get install g++
  ```

##### Instalando o GCC no Mac

1. **Abra o terminal**.
2. **Instale o Homebrew** se ainda não tiver:
  ```bash
  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  ```
3. **Instale o GCC**:
  ```bash
  brew install gcc
  ```

#### 1.4 Primeiro Programa em C++

Vamos começar com um simples programa "Hello, World!".

```Cpp
#include <iostream>

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

##### Explicação do Código

- `#include <iostream>`: Inclui a biblioteca padrão de entrada e saída.
- `Int main() { ... }`: Define a função principal do programa.
- `Std::cout`: Utilizado para imprimir saída na tela.
- `<<`: Operador de inserção de fluxo.
- `Std::endl`: Insere uma nova linha na saída.

### Capítulo 2: Fundamentos do C++

#### 2.1 Variáveis e Tipos de Dados

Variáveis são espaços de memória que armazenam valores. Em C++, cada variável precisa ser declarada com um tipo específico.

##### Tipos de Dados Básicos

- **int**: Números inteiros.
  ```Cpp
  int idade = 25;
  ```
- **float**: Números de ponto flutuante.
  ```Cpp
  float altura = 1.75;
  ```
- **double**: Números de ponto flutuante com maior precisão.
  ```Cpp
  double pi = 3.14159;
  ```
- **char**: Caractere único.
  ```Cpp
  char inicial = 'A';
  ```
- **bool**: Valor booleano (`true` ou `false`).
  ```Cpp
  bool aprovado = true;
  ```

#### 2.2 Operadores

##### Operadores Aritméticos

- `+` Adição
- `-` Subtração
- `*` Multiplicação
- `/` Divisão
- `%` Módulo (resto da divisão inteira)

```cpp
int a = 10;
int b = 3;
int soma = a + b;        // 13
int diferenca = a - b;  // 7
int produto = a * b;    // 30
int quociente = a / b;  // 3
int resto = a % b;      // 1
```

##### Operadores Relacionais

- `==` Igual a
- `!=` Diferente de
- `>` Maior que
- `<` Menor que
- `>=` Maior ou igual a
- `<=` Menor ou igual a

```cpp
bool resultado1 = (a == b); // false
bool resultado2 = (a > b);  // true
```

##### Operadores Lógicos

- `&&` E lógico
- `||` Ou lógico
- `!` Não lógico

```cpp
bool condicao = (a > b) && (b < 5); // true
```

#### 2.3 Estruturas de Controle

##### If/Else

```cpp
int numero = 10;
if (numero > 0) {
    std::cout << "Número positivo" << std::endl;
} else {
    std::cout << "Número não positivo" << std::endl;
}
```

##### Switch

```cpp
char letra = 'a';
switch (letra) {
    case 'a':
        std::cout << "Vogal A" << std::endl;
        break;
    case 'e':
        std::cout << "Vogal E" << std::endl;
        break;
    default:
        std::cout << "Outra letra" << std::endl;
        break;
}
```

##### Laços de Repetição

###### For

```cpp
for (int i = 0; i < 10; ++i) {
    std::cout << i << " ";
}
```

###### While

```cpp
int count = 0;
while (count < 10) {
    std::cout << count << " ";
    ++count;
}
```

###### Do-While

```cpp
int count = 0;
do {
    std::cout << count << " ";
    ++count;
} while (count < 10);
```

### Capítulo 3: Programação Orientada a Objetos

#### 3.1 Classes e Objetos

Classes são os blocos de construção fundamentais da programação orientada a objetos. Elas definem tipos de dados que agrupam dados e funções.

##### Definindo uma Classe

```cpp
class Carro {
public:
    std::string marca;
    std::string modelo;
    int ano;

    void exibirInformacoes() {
        std::cout << "Marca: " << marca << ", Modelo: " << modelo << ", Ano: " << ano << std::endl;
    }
};
```

##### Criando um Objeto

```cpp
Carro meuCarro;
meuCarro.marca = "Toyota";
meuCarro.modelo = "Corolla";
meuCarro.ano = 2020;

meuCarro.exibirInformacoes();
```

#### 3.2 Construtores

Construtores são funções especiais que são chamadas quando um objeto é instanciado.

```Cpp
class Carro {
public:
    std::string marca;
    std::string modelo;
    int ano;

    // Construtor
    Carro(std::string m, std::string mo, int a) : marca(m), modelo(mo), ano(a) {}

    void exibirInformacoes() {
        std::cout << "Marca: " << marca << ", Modelo: " << modelo << ", Ano: " << ano << std::endl;
    }
};

// Uso do construtor
Carro meuCarro("Toyota", "Corolla", 2020);
meuCarro.exibirInformacoes();
```

#### 3.3 Herança

A herança permite que uma classe derive de outra, herde seus atributos e métodos.

```Cpp
class Veiculo {
public:
    std::string marca;
    int ano;

    void exibirInformacoes() {
        std::cout << "Marca: " << marca << ", Ano: " << ano << std::endl;
    }
};

class Carro : public Veiculo {
public:
    std::string modelo;

    void exibirInformacoes() {
        Veiculo::exibirInformacoes();
        std::cout << "Modelo: " << modelo << std::endl;
    }
};

// Uso da herança
Carro meuCarro;
meuCarro.marca = "Toyota";
meuCarro.ano = 2020;
meuCarro.modelo = "Corolla";
meuCarro.exibirInformacoes();
```

### Capítulo 4: Bibliotecas e Manipulação de Arquivos

#### 4.1 Bibliotecas Padrão

A biblioteca padrão do C++ oferece uma ampla gama de funcionalidades, desde manipulação de strings até algoritmos complexos.

##### Incluindo Bibliotecas

```cpp
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
```

#### 4.2 Manipulação de Arquivos

##### Leitura e Escrita em Arquivos

```cpp
#include <fstream>

int main() {
    // Escrevendo em um arquivo
    std::ofstream arquivoSaida("exemplo.txt");
    arquivoSaida << "Hello, World!" << std::endl;
    arquivoSaida.close();

    // Lendo de um arquivo
    std::ifstream arquivoEntrada("exemplo.txt");
    std::string linha;
    while (std::getline(arquivoEntrada, linha)) {
        std::cout << linha << std::endl;
    }
    arquivoEntrada.close();

    return