Programação Orientada a Objeto com C++ (2024)

LEP - 01447: Programação Orientada a Objeto em C++ (Graduação) 

• Pré-requisito: 

  • MAT 01207 (Cálculo Numérico) ; 

  • MAT 01102 (Fundamentos da Ciência da Computação) ou 

  • LEP01580 (Fundamentos de Programação em C++).

  • LEP01348 - Introdução ao Projeto de Engenharia. 

• Créditos: 3 

• Carga Horária: 57h (3*17)

Horários das aulas

• Segunda e quarta das 10:00h às 12:00h

Sala

• Sala de aula do LDSC.

Equipamentos

• Computadores com sistema operacional Gnu/Linux - Fedora.

Monitoria

• Nome do monitor: 

  • Atualmente sem monitor.

• Horário de monitoria: 

  • Quinta feira: 10:00 - 12:00 hs

  • Segunda a sexta: 13:00 - 14:00 hs

  • Quarta feira: 18:00 - 20:00 hs

Comunicação

• Classroom da disciplina 2024/1 

• Telegram da disciplina 2024/1

Objetivos

• Após aprovação na disciplina o aluno deve saber:

• Desenvolver soluções de softwares utilizando orientação a objetos e modelagem UML.

• Usar conceitos básicos e intermediários de C++.

• Usar bibliotecas padrões de C++.

• Usar compiladores (g++).

• Usar sistemas de controle de versões (git/github).

• Idealmente já deve ter um rascunho do projeto que será desenvolvido na disciplina de  "Projeto de Software Aplicado à Engenharia"

Material de ajuda disponibilizado via github

• Repositório com material de ajuda sobre softwares e sistemas utilizados aqui.

Modelos de documentos e projetos

• Para uso dos modelos é necessário conhecimentos básicos de git/github/lyx, apresentados em sala de aula.

• Os modelos são disponibilizados no repositório do ldsc: https://github.com/ldsc. 

• A metodologia para desenvolvimento do projeto é descrita aqui (inclui lista de projetos desenvolvidos). 

• O modelo de desafio tecnológico pode ser obtido aqui.

• O modelo de projeto pode ser obtido aqui.

Parte I - Programação Orientada a Objetos e Fundamentos do Tipo

(Cobre a Ementa: Classes, Métodos, Tipos definidos pelo usuário, Gerenciamento de Memória)

Capítulo 1: Definição de Classes e Objetos

- Protótipos, Declaração vs Definição, Controle de Acesso (public, private, protected).

- Atributos e Métodos (normais, estáticos, constantes, inline).

Capítulo 2: Estudo de Caso: Implementação de Classes em Várias Linguagens

- Comparativo de sintaxe e abordagem.

Capítulo 3: Métodos e Comportamentos

- Implementação detalhada, escopo e `this`.

Capítulo 4: Funções Avançadas: Lambdas, Bind e std::function

- Sobrecarga de funções, Funções Lambda, std::function, std::bind.

Capítulo 5: Gerenciamento de Memória e Ponteiros

- Ponteiros brutos (raw), `nullptr`.

- Smart Pointers: `unique_ptr`, `shared_ptr`, `weak_ptr`.

Capítulo 6: Ciclo de Vida: Construtores e Destrutores

- Tipos de construtores, inicialização, Destrutor virtual.

- Palavras-chave: `default`, `delete`, `override`, `final`.

Parte II - Relacionamentos, Herança e Polimorfismo

(Cobre a Ementa: Herança simples e múltipla, Associações, Polimorfismo, Friend, Sobrecarga de Operadores)

Capítulo 7: Implementando Associações entre Classes

- Agregação, Composição e Dependência.

Capítulo 8: Encapsulamento e Classes Amigas (Friend)

- O uso de `friend` para classes e funções.

Capítulo 9: Herança Simples

- Conceitos básicos, visibilidade na herança.

Capítulo 10: Herança Múltipla

- Desafios e resolução de conflitos.

Capítulo 11: Polimorfismo

- Métodos virtuais, Classes Abstratas e Interfaces.

Capítulo 12: Sobrecarga de Operadores

- Sobrecarga de operadores unários e binários.

- Exemplo prático: A classe `complex`.

Parte III - Entrada e Saída de Dados (I/O) e Persistência

(Cobre a Ementa: Biblioteca de E/S, iostream, fstream, sstream, Filesystem, manipulação de arquivos)

Capítulo 13: Fundamentos de Entrada e Saída (Streams)

- Classes `istream`, `ostream`, `iostream`.

- Redirecionamento de E/S.

Capítulo 14: Resumo Prático de I/O e Formatação

- Manipuladores de `<iomanip>`, `format` e `print` (C++23).

Capítulo 15: Persistência de Dados em Disco

- Uso de `<fstream>` para arquivos texto e binários.

Capítulo 16: A Biblioteca Filesystem (C++17)

- Manipulação de caminhos (`path`), diretórios e iteradores.

Capítulo 17: Manipulação de Arquivos Estruturados

- Trabalhando com formatos CSV, JSON e XML.

Parte IV - Tipos Utilitários e Vocabulário do C++ Moderno

(Cobre a Ementa: Strings, Pair, Tuple, Variant, Optional, Bitset, Complex)

Capítulo 18: Manipulação de Texto

- A classe `<string>` e `<string_view>`.

Capítulo 19: Agregados Heterogêneos

- Classes `<pair>`, `<tuple>`, `initializer_list`.

Capítulo 20: Tipos Algébricos e Tratamento de Valores

- O uso de `<variant>`, `<optional>`, `<any>` e `<expected>` (C++23).

Capítulo 21: Números Complexos

- A classe `<complex>`.

Capítulo 22: Manipulação de Bits

- A classe `<bitset>` e operadores bit-a-bit.

Parte V - A Biblioteca Padrão (STL) e Algoritmos

(Cobre a Ementa: STL, Containers, Iteradores, Ranges, Algoritmos Genéricos)

Capítulo 23: Introdução à STL

- Conceitos de Containers e Iteradores.

Capítulo 24: Containers Sequenciais

- Uso de `<vector>`, `<list>`, `<deque>`.

Capítulo 25: Adaptadores de Container

- Uso de `<stack>`, `<queue>`, `<priority_queue>`.

Capítulo 26: Estudo de Caso: Agenda de Contatos

- Aplicação prática dos containers.

Capítulo 27: Containers Associativos

- Uso de `<set>`, `<multiset>`, `<map>`, `<multimap>`.

Capítulo 28: Código Genérico e Algoritmos

- Funções genéricas e algoritmos da STL.

Capítulo 29: Objetos de Função (Functors)

- Predicados e operações customizadas.

Capítulo 30: Introdução à Biblioteca Ranges (C++20)

- Views, pipelines e algoritmos com ranges.

Parte VI - Tópicos Avançados e Modernização

(Cobre a Ementa: Templates, Concepts, Exceções, Coroutines, Modules, Contracts)

Capítulo 31: Namespaces e Organização

- Definição de escopo e `namespace`.

Capítulo 32: Tratamento de Exceções

- Blocos `try-catch`, lançamento e boas práticas.

Capítulo 33: Conversões de Tipo (Casting)

- `static_cast`, `dynamic_cast`, `reinterpret_cast`, `const_cast`.

Capítulo 34: Templates (Fundamentos)

- Tipos genéricos em funções e classes.

Capítulo 35: Uso Avançado de Templates

- Especialização e Metaprogramação básica.

Capítulo 36: Concepts (C++20)

- Restrições em templates e tipagem forte.

Capítulo 37: Corrotinas (Coroutines)

- Programação assíncrona moderna.

Capítulo 38: Novas Funcionalidades do C++20/23

- Visão geral das atualizações da linguagem.

Capítulo 39: Programação por Contratos (Contracts - C++26)

- Pré-condições, pós-condições e asserções.

Capítulo 40: Módulos (Modules - C++20)

- Substituição dos headers, importação e exportação.  

Veja lista de referências bibliográficas em: Bibliografia Programação