Configurando o ambiente

Prévia do material em texto

Aula1: Configurando o ambiente
Prof. Germano Chacon
Para Próxima Aula instalar o DEV C
 Objetivo: configurar o ambiente dev C para executar e debuggar o código
Instale o deV C com as configurações padrão
Teste o código da pilha da última aula
1 Ativar o debugger
Abra o Dev-C++.Vá até "Tools" > "Compiler Options".
Na aba "Settings", selecione "Linker" e marque a opção "Generate Debugging Information".
Vá na aba "Code Generation" e selecione a opção "No optimization" (-O0).
Clique em OK e recompile o código.
5
2 Usando o debug
 Adicionar Breakpoints
Abra seu código e clique na margem esquerda ao lado da linha onde deseja parar a execução (isso cria um breakpoint).
Recomendo adicionar breakpoints logo após chamadas de push() e pop() para ver as alterações na pilha.
3. Iniciar o Debug
Vá até "Executar" > "Compilar e Depurar (F5)".Quando a execução parar no breakpoint, você poderá inspecionar as variáveis.
Visualizar Variáveis 
Usar "Step Over" e "Step Into"Use F7 (Step Over) para avançar linha por linha sem entrar nas funções.
Use F8(Step Into) para entrar nas funções push() e pop() e ver como pilha e topo são modificados.
7
Ponteiros em C
Introdução aos Ponteiros
Definição e Objetivos
Os ponteiros são variáveis que armazenam endereços de outras variáveis. Eles são essenciais para trabalhar com arrays, alocação dinâmica e manipulação eficiente da memória.
Por que Usar Ponteiros?
Vantagens e Aplicações
Os ponteiros são variáveis especiais em C que armazenam endereços de memória, permitindo acesso indireto a outras variáveis.
 Cada variável tem um nome, tipo, valor e endereço.
 Ponteiros possibilitam operações como leitura e alteração de valores sem utilizar diretamente o nome da variável.
Declarações de ponteiros utilizam o símbolo * e os operadores unários & e * são usados para obter endereços e acessar valores. 
.
Declaração
Os ponteiros são declarados pelo símbolo * entre o tipo e o nome da variável. A forma geral da declaração é:
Tipo_da_variável * Nome_da_Variável;
Operadores
Agora confira dois tipos de operadores!
Operador unário & ou ponteiro constante
Tem a função de obter o endereço de memória de uma variável.
Operador unário * de indireção
É usado para fazer a deferência.
int x = 5;
int *pt_x;
/* Ponteiro pt_x recebe o endereço de memória da variável x */
pt_x = &x;
Operadores
Indireção múltipla
O endereço do ponteiro pode ser obtido da seguinte
Assim, um ponteiro pode armazenar o endereço de outro ponteiro, ocasionando uma indireção múltipla.
#include 
#include // Para malloc, calloc e free
int main() {
int ** pt2; /*ponteiro para ponteiro do tipo inteiro*/
int * pt1; /*ponteiro para o tipo inteiro*/
int x = 10;
pt2 = &pt1;
pt1 = &x;
*pt1 = 30;
**pt2 = 50;
return 0;
}
Memória do Computador
Nesta seção, iremos explorar diferentes tipos de memória do computador, como a stack e o heap, e seus papéis na gestão de ponteiros.
exemplo
 #include 
 #include 
 int main(void) {
 //v_num é a variável que
 //será apontada pelo ponteiro
 int v_num = 10;
 //declaração de variável ponteiro
 int *ptr;
 //atribuindo o endereço da variável v_num ao ponteiro
 ptr = &v_num;
 printf("Utilizando ponteiros\n\n");
 printf ("Conteudo da variavel v_num: %d\n", v_num);
 printf ("Endereço da variavel v_num: %x \n", &v_num);
 printf ("Conteudo da variavel ponteiro ptr: %d", *ptr);
 getch();
 return(0);
 }
Stack e Heap
Stack (Pilha)
A stack é uma área de memória onde as variáveis locais são alocadas. Ela opera em um modelo LIFO, ideal para funções e variáveis temporárias.
O heap é utilizado para a alocação dinâmica de memória. Ao contrário da stack, a memória deve ser gerenciada manualmente, permitindo a criação de estruturas de dados complexas.
Heap
#include 
void contador() {
 static int count = 0; // Inicializada apenas na primeira chamada
 count++;
 printf("Contador: %d\n", count);
}
int main() {
 contador(); // Saída: Contador: 1
 contador(); // Saída: Contador: 2
 contador(); // Saída: Contador: 3
 return 0;
}
16
Segmentos de Memória
Segmento de Dados
Segmento de Código
Segmento de Pilha
Armazena variáveis globais e estáticas, tendo um tamanho fixo durante a execução do programa.
Contém o código executável do programa. Ele é carregado na memória para ser processado pelo CPU.
Aqui são alocadas as variáveis locais e gerenciamento de chamadas de função, essencial para a execução de funções recursivas.
A alocação de memória
Definição e importância
A alocação de memória refere-se ao processo de reservar espaço na memória para dados e programas em execução. É crucial para o desempenho eficiente do sistema e gerenciamento de recursos.
Alocação Estática
Características principais
Na alocação estática, a memória é reservada durante a compilação. A quantidade de memória é fixa e não muda, garantindo eficiência.
O modificador 'static' define a duração da memória alocada, tornando-a disponível durante toda a execução do programa.
Uso de modificador static
Alocação Automática
Funcionamento básico
Gestão convenient
A alocação automática ocorre quando as variáveis são declaradas em uma função. A memória é alocada na pilha e liberada quando a função termina.
Este tipo de alocação é simples e não requer gerenciamento manual da memória, reduzindo o risco de vazamentos.
exemplo
 	#include 
 	int a = 0; // variável global, alocação estática
	void incrementa(void) 	{
 		int b = 0; // variável local, alocação automática 		static int c = 0; // variável local, alocação estática
		printf ("a: %d, b: %d, c: %d\n", a, b, c);
		a++;
 		b++;
 		c++; 
	} 	
		int main(void) 	{
		int i;
		for (i = 0; i 
#include // Para malloc, calloc e free
int main() { // Usando malloc para alocar um array de 3 inteiros
 int *ptr1 = (int *)malloc(3 * sizeof(int)); 
 if (ptr1 == NULL) { 
 printf("Falha na alocação de memória com malloc.\n");
 return 1; } // Preenchendo o array e exibindo valores (valores podem ser lixo) printf("Valores alocados com malloc:\n");
 for (int i = 0; iimage6.png
image7.png
image8.jpeg
image9.jpeg
image10.jpeg
image13.png
image14.jpeg
image15.png
image16.svg
 
.MsftOfcThm_Accent1_Fill_v2 {
 fill:#734B67; 
}
.MsftOfcThm_Accent1_Stroke_v2 {
 stroke:#734B67; 
}
 
image17.jpg
image18.jpg
image19.png
image20.png
image21.jpeg
image22.jpeg