Definindo segundos em um ano

#define HORAS_POR_DIA 24
#define MINUTOS_POR_HORA 60
#define SEGUNDOS_POR_MINUTO 60
#define SEGUNDOS_ANUAIS (365 * HORAS_POR_DIA * MINUTOS_POR_HORA * SEGUNDOS_POR_MINUTO)

volatile

Um especificador de tipo que informa ao compilador que o valor da variável pode mudar a qualquer momento, evitando otimizações. Usado para acessar registradores especiais ou para comunicação entre threads/processos.

static

1. Variáveis locais em funções com static tornam-se estáticas, com tempo de vida igual a variáveis globais, mas escopo local. 2. Variáveis globais estáticas são restritas ao arquivo atual. Em C++: - Membros estáticos de classes: declarados na classe, inicializados fora, compartilhados entre objetos. - Funções membro estáticas: acessam apenas membros estáticos, compartilhados entre objetos.

extern

1. Declarar variáveis antes do uso em qualquer lugar do arquivo. 2. Referenciar variáveis de outros arquivos como globais. 3. Chamar funções de outros arquivos sem incluir o cabeçalho. 4. Em C++, extern "C" permite chamar código C.

new/delete vs malloc/free

1. new/delete são operadores, enquanto malloc/free são funções da biblioteca C. 2. new/delete chamam construtores e destrutores, malloc/free apenas alocam memória.

struct vs union

1. struct permite membros de tipos diferentes com espaços de memória independentes. 2. union tem membros compartilhando a mesma memória; alterar um membro afeta os outros. O tamanho da union é o do maior membro.

const

Modifica variáveis, parâmetros ou valores de retorno como constantes. Define propriedades de leitura apenas. Diferencia entre ponteiro constante e ponteiro para constante.

sizeof vs strlen

1. sizeof calcula o tamanho em bytes de um tipo ou variável. 2. strlen calcula o comprimento de uma string, parando em '\0'.

typedef vs define

1. typedef cria um alias para um tipo de dados. 2. define realiza substituição de texto sem verificação de tipo.

const vs define para constantes

define apenas substitui texto durante a pré-compilação, sem alocação de memória. const protege dados contra modificação. Geralmente, const é preferível.

Diferenças entre structs em C e C++

Em C: default public, sem inicialização de membros, uso obrigatório de struct ou typedef, tamanho zero para structs vazias, sem herança ou funções. Em C++: acesso restrito, inicialização de membros permitida, uso direto após definição, tamanho 1 para structs vazias, herança e funções permitidas.

class vs struct

1. struct default public, class default private. 2. struct não suporta herança, class suporta. 3. class pode definir templates, struct não.

Verificação de endianness com union

Big-endian: byte mais significativo no endereço mais baixo. Little-endian: byte menos significativo no endereço mais baixo. Exemplo:

#include <stdio.h>
int main() {
    union {
        int valor[2];
        short teste;
    } u;
    u.teste = 0x1234;
    if (u.valor[0] == 0x12 && u.valor[1] == 0x34) {
        printf("Big-endian detectado!\n");
    }
    return 0;
}

Conversão de endianness

Usar deslocamento de bits e operação AND com 0x00FF.

enum

Os valores dos membros são incrementados automaticamente em 1 a partir do anterior.

register

Variáveis armazenadas em registradores, não podem ser endereçadas, devem ser de tipos inteiros.

auto

Variáveis automáticas, geralmente locais, armazenadas na pilha.

Valor l vs valor r

Valor l: geralmente aparece à esquerda de uma atribuição, pode ser modificado. Valor r: geralmente à direita, não pode ser atribuído diretamente.

Avaliação de curto-circuito

Avaliação de expressões lógicas onde o segundo operando não é avaliado se o primeiro já determina o resultado.

++a vs a++

Incremento pré-fixado vs pós-fixado.

Variáveis locais com mesmo nome de globais

Sim, variáveis locais escondem variáveis globais.

Variáveis globais em múltiplos arquivos .c

Sim, usando static em cada arquivo .c para variáveis globais com mesmo nome.

gets vs scanf

1. gets aceita espaços, scanf para em espaços. 2. gets para strings, scanf para tipos básicos. 3. gets retorna char*, scanf retorna int com número de atribuições.

Atuação de volatile e extern na compilação

volatile afeta a otimização durante a compilação. extern atua na etapa de ligação.

Retorno de printf

Retorna o número de caracteres escritos.

char* str1="hello" vs char str2[]="hello"

str1 é ponteiro para constante, conteúdo imutável. str2 é array mutável.

Acessando variáveis globais com mesmo nome de locais

Usar uma função ou a palavra-chave extern.

Memória

Alocação de memória em C

1. Pilha: variáveis locais, liberada automaticamente. 2. Área estática/global: variáveis globais e estáticas. 3. Heap: alocação manual com malloc/free, new/delete.

Gerenciamento de memória em C++

Dividido em regiões: código, dados, BSS, pilha, heap, mapeamento de arquivos.

Diferenças entre pilha e heap

1. Alocação: pilha automática, heap manual. 2. Tamanho: pilha limitada, contígua; heap expansível, fragmentada. 3. Eficiência: pilha rápida, heap lenta com possível fragmentação.

Papel da pilha

1. Armazenar variáveis temporárias e valores de retorno. 2. Base para multithreading, cada thread com sua pilha.

Estouro de pilha/heap

Causado por recursão profunda, acesso a arrays fora dos limites, ponteiros inválidos ou falta de liberação de memória dinâmica.

Vazamento de memória

Memória alocada não liberada, sem referência.

Evitar vazamentos

1. Gerenciar alocações com listas. 2. Pares de alocação/liberação. 3. Usar ponteiros inteligentes.

Alinhamento de bytes

Organização de dados na memória para eficiência de acesso. Necessário para structs e unions.

Ordem de empilhamento de parâmetros em C

Da direita para a esquerda.

Tamanho máximo da pilha

Windows: 2MB, Linux: 8MB, verificado com ulimit -s.

Alocar 1.2GB em sistema com 1GB de memória física

Sim, pois malloc aloca memória virtual.

Funções de string e segurança

strcat pode causar estouro; usar strncat. strcpy pode causar estouro; usar strncpy.

malloc vs calloc vs realloc

1. malloc aloca sem inicializar. 2. calloc aloca e inicializa com zeros. 3. realloc redimensiona memória existente.

Ponteiros

O que é um ponteiro

Variável que armazena endereço de memória.

Tamanho de ponteiros

Em sistemas 32-bit, 4 bytes para qualquer tipo de ponteiro.

Ponteiro para array vs array de ponteiros

Ponteiro para array aponta para um array; array de ponteiros armazena ponteiros.

Ponteiro de função vs função que retorna ponteiro

Ponteiro de função aponta para uma função; função retorna ponteiro.

Nome de array vs ponteiro

1. Nome de array representa endereço do primeiro elemento; ponteiro armazena endereço. 2. sizeof: ponteiro retorna tamanho do ponteiro, array retorna tamanho total.

Ponteiro constante vs constante ponteiro

int * const p: ponteiro constante, endereço imutável. const int *p: ponteiro para constante, valor imutável.

Ponteiro vs referência

1. Ponteiro é endereço, referência é alias. 2. Referência deve ser inicializada e não pode ser nula. 3. sizeof diferente.

Ponteiros selvagens

Ponteiros não inicializados ou apontando para memória liberada. Solução: inicializar com NULL, verificar alocação, liberar e definir como NULL.

Ponteiros inteligentes em C++

Classes que gerenciam ponteiros: shared_ptr (contagem de referências), unique_ptr (exclusivo), weak_ptr (para evitar ciclos).

Problemas de memória com ponteiros inteligentes

Evitar ciclos de referência com weak_ptr.

Nome de array vs endereço de array

Para arrays unidimensionais, num+1 move para próximo elemento, &num+1 move para próximo array. Similar para arrays bidimensionais.

Por que referências além de ponteiros

Referências evitam ponteiros nulos, selvagens e modificações acidentais.

Benefícios de ponteiros

1. Alocação dinâmica. 2. Manipulação de estruturas como listas. 3. Acesso a strings.

Conversão entre ponteiro e referência

Ponteiro para referência: usar *; referência para ponteiro: usar &.

sizeof de nome de array vs &array

sizeof(array) retorna tamanho do array; sizeof(&array) retorna tamanho do ponteiro.

Índice de array negativo

Possível, acessa endereços anteriores.

Uso de ponteiro após free

O ponteiro ainda aponta para endereço liberado; deve ser definido como NULL após free.

Aritmética de ponteiros

Subtração entre ponteiros é válida; adição não.

Pré-processamento

Erro de pré-processamento #error

Gera uma mensagem de erro durante a compilação.

#ifndef #define #endif

Previne inclusão múltipla de cabeçalhos.

#include "" vs #include <>

#include "" busca primeiro em diretórios locais; #include <> busca em diretórios do sistema.

typedef vs #define

typedef é palavra-chave para alias; #define é substituição textual.

Desvantagens de #define

1. Sem verificação de tipo. 2. Difícil depuração. 3. Problemas de precedência.

Papel dos cabeçalhos

1. Acesso a bibliotecas e proteção de código. 2. Verificação de tipos pelo compilador.

Processo de compilação em C++

Pré-processamento: expansão de macros, diretivas condicionais. Compilação: análise de sintaxe, otimização, geração de assembly. Montagem: conversão para código de máquina. Ligação: combinação de objetos em executável.

Variáveis estáticas em cabeçalhos

Não recomendado, pois causa múltiplas definições e desperdício de memória.

enum vs #define

enum é verificado durante compilação; #define é substituição textual.

const vs #define

const é verificado e aloca memória; #define não.

Funções inline vs macros

Funções inline são inseridas durante compilação, com verificação de tipo.

Funções

Macros vs funções inline

Macros: substituição textual, sem verificação de tipo. Funções inline: código inserido, verificação de tipo, suporta otimizações.

Diferenças entre funções normais e inline

Funções inline têm código simples, não suportam loops complexos, são inseridas diretamente.

Por que destrutores devem ser virtuais

Para garantir que destrutores de classes derivadas sejam chamados ao deletar via ponteiro base, evitando vazamentos.

Por que destrutor padrão não é virtual

Evitar overhead de vtable em classes que não serão herdeiras.

Funções estáticas vs virtuais

Estáticas: resolvidas em tempo de compilação. Virtuais: resolvidas em tempo de execução com vtable.

Sobrecarga vs substituição

Sobrecarga: mesmo nome, diferentes parâmetros. Substituições: mesma assinatura em classes base e derivadas.

Princípio de polimorfismo com funções virtuais

vtable mapeia funções virtuais; classes derivadas substituem entradas.

Chamada de função em C

Usa pilha para parâmetros, variáveis locais e retornos.

Função select

Monitora descritores de arquivo para leitura/escrita. Usa fd_set.

Índice de array negativo em funções

Possível, mas não recomendado.

Macros vs funções

Macros aumentam tempo de compilação; funções aumentam tempo de execução.

ASSERT()

Macro que verifica expressão em tempo de execução, aborta se falsa.

strcpy vs memcpy

strcpy para strings, para em '\0'; memcpy para qualquer dado, com tamanho especificado.

Estruturas de Dados e Algoritmos

map vs set em STL

Ambos usam árvore rubro-negra. map armazena pares chave-valor; set armazena elementos únicos ordenados.

vector vs deque

vector: array dinâmico, alocação contígua. deque: array duplamente encadeado, eficiente para inserções em ambas pontas.

allocator em STL

Gerencia alocação/liberação de memória, com dois níveis de configuradores para eficiência.

Remoção com iteradores em STL

Em containers de sequência, erase invalida iteradores seguintes; em containers associativos, afeta apenas o iterador atual.

map vs unordered_map

map ordenado com árvore; unordered_map não ordenado com tabela hash.

vector vs list

vector: acesso rápido, inserção/remoção lenta. list: inserção/remoção rápida, acesso lento.

Iteradores vs ponteiros

Iteradores abstraem acesso a elementos, suportam diferentes containers.

resize vs reserve

resize altera número de elementos; reserve altera capacidade.

Arrays vs listas ligadas

Arrays: acesso rápido, tamanho fixo. Listas: inserção/remoção rápida, acesso lento.

Detectar ciclo em lista ligada

Usar tabela hash ou abordagem de ponteiro rápido/lento.

Tabela de símbolos

Implementação baseada em array.

Lista ligada

Estrutura com nós contendo dados e ponteiro para próximo.

Lista duplamente ligada e circular

Nós com ponteiros anterior e próximo; circular: último aponta para primeiro.

Pilha

Estrutura LIFO, implementada com array ou lista ligada.

Fila

Estrutura FIFO, implementada com array circular ou lista ligada.

Árvore binária

Nós com dois filhos; travessias pré-ordem, em-ordem, pós-ordem.

Classes e Abstração de Dados

Acesso a membros de classe em C++

public, protected, private controlam visibilidade.

Ponteiro vs referência

Referência deve ser inicializada, não pode ser nula; ponteiro pode.

struct vs class

struct default public; class default private.

Programação orientada a objetos vs genérica

OOP: objetos como unidades básicas. Genérica: tipos parametrizados.

Referência de valor r vs valor l

Valor l: mutável, endereçável. Valor r: temporário, não endereçável.

Por que construtores não são virtuais

Objeto ainda não completamente construído durante construção.

Funções membro estáticas vs não estáticas

Estáticas: acessam apenas membros estáticos, compartilhadas.

Orientação a Objetos

OOP vs procedimento

OOP: objetos com dados e métodos. Procedimento: passos sequenciais.

Características básicas da OOP

Encapsulamento, herança, polimorfismo.

Cópia superficial vs profunda

Superficial: copia ponteiros; profunda: copia dados.

Amigos em C++

Funções ou classes com acesso a membros privados.

Herança de construtores/destrutores

Não são herdados diretamente.

Funções que não podem ser virtuais

Funções não membro, estáticas, construtores, inline, amigos.

Implementação de vector

Array dinâmico com realocação.

Expansão de vector

Aloca nova memória, copia dados, libera antiga.

Remoção de elementos e iteradores

Em containers de sequência, invalida iteradores; em associativos, afeta apenas o atual.

Compreendendo iteradores

Suportam acesso aleatório ou bidirecional.

Composição de iteradores

Classes com operadores sobrecarregados.

Implementação de ponteiro inteligente

Classe com contagem de referências e liberação automática.

Finalidade de iteradores em STL

Abstraem acesso a elementos de containers.

Remoção com iteradores em STL

Varia por tipo de container.

map vs set

map: pares chave-valor; set: elementos únicos.

Papel de allocator em STL

Gerência de memória eficiente.

Armazenamento de dados em map

Usa árvore rubro-negra.

resize vs reserve

resize: altera elementos; reserve: altera capacidade.

Lista de inicialização vs construtor

Lista de inicialização: mais eficiente, necessária para const e referências.

Ordem de inicialização de membros

Baseada na ordem de declaração.

Herança public, protected, private

Controla visibilidade de membros heraddos.

Construtores/destrutores não herdados

Devido à necessidade de inicialização específica.

Prevenir instanciação de classe

Usar construtor privado ou classe abstrata.

Função virtual pura

Declaração sem implementação; classe abstrata.

Casos para lista de inicialização

Para const, referências e membros sem construtor padrão.

Tempo de criação de vtable

Durante a compilação.

Funções Virtuais

Considerações sobre funções virtuais

Apenas funções membro podem ser virtuais; construtores, estáticas não.

Funções não virtuais

Funções não membro, construtores, estáticas, amigos.

Sistemas Operacionais

Processo vs thread

Processo: unidade de alocação de recursos. Thread: unidade de execução.

Processo, thread, coroutine

Processos: independentes. Threads: compartilham recursos. Coroutines: cooperativas.

Quando usar multithreading vs multiprocessing

Multithreading: baixo overhead, compartilhamento fácil. Multiprocessing: isolamento.

Criação de processos

Através de fork() ou chamadas do sistema.

Estados do processo

Criação, pronto, execução, bloqueado, terminado.

Comunicação entre processos (IPC)

Canais, memória compartilhada, sinais, sockets, filas de mensagens, semáforos.

Escolha de IPC

Canais para frequência alta; memória compartilhada para dados grandes.

Processos zumbi, órfãos, daemon

Zumbi: terminado mas não coletado. Órfão: pai terminado. Daemon: processo de fundo.

Problemas de processos zumbi

Esgotamento de PIDs.

Comunicação entre threads

Seções críticas, mutexes, leitores-escritores, variáveis de condição.

Sincronização de threads/processos

Mutexes, leitores-escritores, variáveis de condição.

Threads de kernel vs usuário

Gerenciadas pelo kernel ou espaço do usuário.

Processos daemon

Processos de fundo, desvinculados do terminal.

Algoritmos de escalonamento

FCFS, RR, prioridade, SJF, filas multinível.

Preemptivo vs cooperativo

Preemptivo: interrupção forçada. Cooperativo: cede controle voluntariamente.

Concorrência vs paralelismo

Concorrência: múltiplas tarefas alternando. Paralelismo: múltiplas tarefas simultâneas.

Implementação de IPC com canais

Buffer no kernel, file descriptors.

Deadlock

Espera circular por recursos. Condições: exclusão mútua, retenção, espera circular.

Necessidade de locks em single-core

Sim, para sincronização entre threads.

Mutex vs leitores-escritores

Mutex: exclusão mútua simples. Leitores-escritores: múltiplas leituras, escrita exclusiva.

Semáforos

Contador para controle de acesso a recursos.

Troca de contexto

Salvar/restaurar estado do processo/thread.

Thread pools

Conjunto de threads reutilizáveis para eficiência.

I/O multiplexing

select, poll, epool para monitoramento de descritores.

Canais nomeados

Comunicação entre processos não relacionados.

Sinais

Notificações assíncronas para processos.

Memória compartilhada

Mapeamento de memória entre processos.

Links simbólicos vs duros

Simbólicos: atalhos; duros: referências diretas a inodes.

Bibliotecas estáticas vs dinâmicas

Estáticas: incluídas no executável. Dinâmicas: carregadas em tempo de execução.

Depuração com GDB

Comandos para executar, breakpoints, inspecionar.

Modos kernel vs usuário

Kernel: acesso total. Usuário: acesso restrito.

Tabelas de página

Mapeamento de memória virtual para física.

Implementação de malloc

Gerência de heap com listas de blocos livres.

Faltas de página

Acesso a memória virtual não mapeada.

mmap

Mapeamento de arquivos em memória.

Por que memória virtual

Expansão, proteção, compartilhamento.

Comunicação usuário-kernel

Syscalls, /proc, mmap.

Interrupções

Tratamento assíncrono de eventos. Superior/inferior.

Busybox

Conjunto de ferramentas Unix compactas.

Sistema de arquivos raiz

Primeiro sistema montado pelo kernel.

Spinlocks vs semáforos

Spinlocks: busy-waiting. Semáforos: bloqueio.

Fragmentação de heap

Gerenciamento com listas.

Componentes do kernel Linux

Escalonamento, memória, VFS, rede, IPC.

Componentes do Linux

Kernel, shell, sistema de arquivos, aplicações.

Sincronização vs exclusão mútua

Sincronização: ordem. Exclusão mútua: acesso único.

Comandos comuns

Compressão, memória, CPU, processos, permissões.

Terminação de processos

Normal: return, exit. Anormal: abort, sinais.

Processos especiais

idle, init, kthread.

Funções de multithreading

Criação, junção, desvinculação.

Sinais de condição

Notificação para threads.

Necessidade de concorrência em drivers

Proteção de recursos compartilhados.

Interrupções de software vs hardware

Software: por instrução. Hardware: por dispositivo.

fork vs vfork

fork: cópia. vfork: compartilhamento.

Conceitos de memória virtual

Alocação e gerenciamento eficiente.

Conceitos de programação concorrente

Atomicidade, visibilidade, ordenamento.

Síncrono vs assíncrono

Bloqueante vs não bloqueante.

Programação de Rede

Cabeçalho TCP

Campos para controle de fluxo, confiabilidade.

Funções socket no cliente/servidor

bind, listen, accept, connect, read, write.

Comunicação UDP

Sockets não orientados a conexão.

Modelo de camadas de rede

Aplicação, transporte, rede, enlace, física.

Confiabilidade TCP

Checksum, números de sequência, ACKs, retransmissão.

Janela deslizante e retransmissão

Controle de fluxo para eficiência.

Slow start TCP

Controle de congestionamento incremental.

Three-way handshake e four-way handshake

Estabelecimento e encerramento de conexões TCP.

Por que três handshakes

Para sincronizar números de sequência.

Quatro handshakes para encerramento

Para garantir que todos os dados sejam enviados.

Janela deslizante pequena

Aumenta latência.

Handshakes perdidos

Retransmissão após timeout.

TCP vs UDP

TCP: confiável, orientado a conexão. UDP: rápido, sem garantias.

Resolução de nomes DNS

Cache local, servidores DNS.

Empacotamento/desempacotamento TCP

Limites de mensagem não claros.

Soluções para empacotamento

Tamanho fixo, delimitadores, estrutura definida.

Por que TCP é confiável

Mecanismos de ACK, retransmissão, controle de fluxo.

O que é HTTP

Protocolo para transferência de hipertexto.

Características HTTP

Stateless, baseado em requisições/respostas.

Espera TIME_WAIT

Garante que pacotes finais sejam recebidos.

Casos de uso TCP

Aplicações que requerem confiabilidade.

Casos de uso UDP

Aplicações em tempo real.

IPv4 vs IPv6

Endereçamento, segurança, cabeçalhos.

Endereços IP

Classes, sub-redes.

Endianness na rede

Ordem de bytes.

Funções de String

Implementação de strlen, strcpy, strcmp, strcat, memset, atoi, memcpy.

Protocolos de Comunicação

USART/UART

Comunicação serial assíncrona.

RS232

Interface serial com níveis de tensão definidos.

RS485

Interface serial para longas distâncias.

I2C

Protocolo serial sincronizado com endereçamento.

SPI

Protocolo serial de alta velocidade.

Diferenças SPI vs I2C

Velocidade, complexidade, modo de operação.

CAN bus

Protocolo para redes de automotivo/industrial.

Processamento de áudio/vídeo

Protocolos como I2S, SCCB.

Periféricos de Hardware

GPIO

Configuração de pinos como entrada/saída.

Interrupções externas

Configuração e tratamento.

PWM

Geração de sinais de modulação por largura de pulso.

ADC+DMA

Conversão analógico-digital com DMA para eficiência.

Estrutura interna da CPU

Unidades de controle, execução, memória.

Relação CPU, memória, memória virtual, disco

Hierarquia de armazenamento.

Classificação de processadores ARM

Microprocessadores, microcontroladores, DSPs.

Microprocessadores vs DSPs

General purpose vs processamento de sinais.

Armazenamento

Cache, RAM, ROM, flash.

Tipos de RAM

SRAM, DRAM.

Tipos de ROM

Flash, EEPROM.

Conjuntos de instruções CPU

CISC vs RISC.

Pipeline de CPU

Estágios de execução sobrepostos.

Pipeline em sistemas embarcados

Otimização para desempenho.

Inicialização do U-Boot

Configuração de hardware, carregamento do kernel.

Interrupções vs exceções

Externas vs internas.

DMA vs interrupções

DMA reduz carga da CPU.

Funções de interrupção

Tratamento rápido e retorno.

Parâmetros para kernel

Configuração de hardware.

Desabilitar caches no U-Boot

Evitar inconsistências durante inicialização.

Funções de alocação em drivers

kmalloc, vmalloc.

Princípio de conversão AD

Amostragem, quantização.

Configuração ADC com DMA

Fluxo de configuração.

U-Boot e kernel

Passagem de parâmetros via tags.

RT-Thread

Kernel

Agendador, comunicação, gerenciamento de objetos.

Gerenciamento de threads

Estados, prioridades, criação.

Sincronização entre threads

Semáforos, mutexes, conjuntos de eventos.

Comunicação entre threads

Caixas de correio, filas de mensagens.

Entrevistas em sistemas embarcados

Tópicos comuns.

Mapeamento de memória

Compartilhamento entre processos.

define vs const

Substituição textual vs verificação de tipo.

Arrays vs listas ligadas

Comparação de desempenho.

Ponteiros vs referências

Diferenças semânticas.

Sinais e slots no Qt

Mecanismo de comunicação.

Resistores pull-up no I2C

Garantir níveis lógicos corretos.

Processo de comunicação MQTT

Conexão, publicação, assinatura.

Sincronização de threads em Linux

Mutexes, semáforos, variáveis de condição.

Casos de uso TCP/UDP

Baseado em requisitos de confiabilidade e tempo real.

Ponteiros selvagens

Causas e prevenção.

Mutexes

Exclusão mútua.

Arrays vs ponteiros

Semântica e uso.

Prevenção de inclusão múltipla

Guards de cabeçalho.

Pilhas vs filas

LIFO vs FIFO.

Por que interrupções não passam parâmetros

Assíncronas e independentes.

Formato de frame serial

Bits de início, dados, paridade, parada.

Conceito de interrupção

Tratamento assíncrono de eventos.

Efeito de static

Escopo e tempo de vida.

Processo de interrupção

Da requisição ao tratamento.

O que é polimorfismo

Comportamento múltiplo via interface única.

Alocação de memória em C

Pilha, heap, estática.

struct vs class

Diferenças em C++.

Funções vs interrupções

Síncronas vs assíncronas.

Spinlocks vs semáforos

Comparação.

Detectar ciclos em listas ligadas

Algoritmos como ponteiro rápido/lento.

Considerações multithreading

Sincronização, comunicação, deadlock, sobrecarga.

Implementar strcpy

char* copiar_string(char* destino, const char* origem) {
    char* inicio = destino;
    while ((*destino++ = *origem++) != '\0');
    return inicio;
}

Implementar strcat

char* concatenar_string(char* destino, const char* origem) {
    char* ptr = destino;
    while (*ptr != '\0') ptr++;
    while ((*ptr++ = *origem++) != '\0');
    return destino;
}

Entrevistas em Empresas

Tópicos frequentes em entrevistas para sistemas embarcados, incluindo projetos pessoais, conceitos de memória, ponteiros, multithreading, redes, e habilidades comportamentais.