Referências

Material sobre linguagem C (IME-USP)
- https://www.ime.usp.br/~slago/slago-C.pdf
Material sobre memória e ponteiros (cap2::stanford)
- http://cslibrary.stanford.edu/102/PointersAndMemory.pdf
Notas sobre estruturas de dados e programação (cap4:yale)
- http://cs-www.cs.yale.edu/homes/aspnes/classes/223/notes.pdf
Livro (cap11.9:Write greate code)
- http://pdf.th7.cn/down/files/1312/write_great_code_volume_1.pdf
stackoverflow:O que são e onde estão o stack e heap?
- https://pt.stackoverflow.com/questions/3797/o-que-s%C3%A3o-e-onde-est%C3%A3o-o-stack-e-heap
LEIA LIVROS SOBRE PROGRAMAÇÃO!

Exercícios

Qual o conteúdo das variáveis?

 int main() {
     int c = 10;
     int* d = &c;	
     *d = 20;		
     printf("%d", c);
 }

Qual o conteúdo das variáveis?

 void soma(int a, int b, int* c) {
     *c = a + b;
 }		
 int main() {
     int c = 10;	
     soma(5, 3, &c);
     printf("%d", c);
 }

Qual o conteúdo das variáveis?

 int main() {
     int c = 10;
     int* d = &c;	
     scanf("%d", d);
 }

Qual o conteúdo das variáveis?

 int main() {
     int c = 10;
     int* d = &c;	
     d[0] = 20;		
     printf("%d", c);
 }

Aloque memória no Heap (dinâmica) para um vetor de double de tamanho n

 int n = 100;
 double vetor_na_pilha[n];
 double* vetor_no_heap = //complete;

Qual das formas abaixo nos permite acessar o primeiro elemento do vetor?

 a) vetor_no_heap[0]
 b) *vetor_no_heap
 c) vetor_no_heap
 d) vetor_no_heap->[0]

Qual o tamanho das variáveis a e b abaixo?

 int a[10];
 int* b = malloc( sizeof(int) * 10 );
 char* c = malloc( sizeof(char) * 10 );
 // sizeof(a);
 // sizeof(b);
 // sizeof(c);
 // sizeof(*a);
 // sizeof(*b);
 // sizeof(*c);

Altere o código abaixo para que a memória da estrutura Pessoa seja alocada no heap.

 #include <stdio.h>
 #include <stdlib.h>
 #define MAX_SIZE_NOME 20
 typedef struct {
     int idade;
     long cpf;
     char nome[MAX_SIZE_NOME];
 } Pessoa;

 void ler_pessoa(Pessoa* p) {
     scanf("%s%d%ld", p->nome, &(p->idade), &(p->cpf));
 }

 int main() {
     Pessoa w;
     ler_pessoa(&w);
 }

Implemente uma função chamada swap, a qual recebe a referência para dois inteiros e troca seus conteúdos.
```
 // Se *a == 4 e *b == 3
 void swap(int* a, int* b);
 // Agora *a == 3 e *b == 4
```
Implemente uma função que aloque espaço inicial para uma matriz de dimensões $n\times n$. Essa função deve implementar o seguinte cabeçalho:
```
// Aloca espaço para uma matrix n x n.
// retorna um ponteiro para a memória alocada.
int** new_matrix(int n);
```

Implemente uma função que inicialize a matriz com determinado valor e outra que a imprima.

void init_matrix(int** matrix, int n, int value);
void print_matrix(int** matrix, int n);

A cada chamada à malloc deve existir uma chamada free associada. Implemente uma função que libere o espaço de memória alocado pela função anterior. Essa função deve implementar o seguinte cabeçalho:
```
void free_matrix(int** matrix);
```

O que faz o seguinte código?

char* at(char* c, int i) {
    return &c[i];
}
int main() {    
    char* ptr = malloc(sizeof(char) * 10);  
    *at(ptr, 5) = 'j';
    print(ptr, 10);
    return 0;
}

Imprima toda a string abaixo, caracter por caracter (putchar) sem que nenhuma variável adicional seja alocada.

#include <stdio.h>
int main() {
    char* frase = "Frase de exemplo para teste";
    return 0;
}

No trecho de código a seguir, identifique onde cada uma das variáveis está alocada: pilha de chamadas ou heap. E identifique possíveis erros.

int main() {
    char nome[10];
    char* nomeptr;    
    nomeptr = "Jean";    
    int* v = malloc( sizeof(int * 10) );    
    for (int i = 0; i < 10; i++)
        free(v[i]);
}

O que faz o seguinte código?

int* x = NULL;
if (x) x = malloc(sizeof(int));

Como definiríamos e alocaríamos um vetor de struct vector* de tamanho 100? Como variável local e como variável no Heap.
Como definiríamos um vetor de strings char* de tamanho 100? Como variável local e como variável no Heap.
Data a struct Fração definida abaixo, declare uma varíavel do tipo Fração.
```
struct Fracao {
    int numerador;
    int denominador;
};
```

Data a struct Fração definida abaixo, declare uma varíavel do tipo Fração.

typedef struct {
    int numerador;
    int denominador;
}  Fracao;

Data a struct Fração definida abaixo, declare uma varíavel do tipo Fração.

// **** interface.h ****
typedef struct _fracao Fracao;

// **** implementação.c ****
#include "interface.h"
struct _fracao {
    int numerador;
    int denominador;
};

Há algo de errado com este código?

typedef struct {
    int* vetor;
    int tamanho;
} array;

int main() {
    array* a = malloc(sizeof(array));
    a->tamanho = 10;    
    for (int i = 0; i < a->tamanho; i++)
        a->vetor[i] = a->vetor[i+1];
}

Há algo de errado com este código?

typedef struct {
    int* vetor;
    int tamanho;
} array;

int main() {
    array a;
    a.tamanho = 10;    
    a.vetor = malloc(sizeof(int) * a.tamanho);
    for (int i = 0; i < a->tamanho; i++)
        a[i] = a[i+1];
}

Para dobrar o tamanho de um vetor previamente alocado. O código a seguir faz isso corretamente?

#include <stdlib.h>
int main() {
    int* a = malloc(sizeof (int) * 20);        
    realloc(a, sizeof(int) * 40);
}

Qual a diferença entre malloc e calloc?
O que está sendo definido na linha de códgigo a seguir?
```
int v[10][3][4][2][2];
```
Aloque memória para um vetor de tamanho 100 tipo array, definido a seguir.
```
typedef int* array;
array* v; // alocar 100 posições do tipo array.
```
Que tipo de estrutura pode ser armazenada em v?
Implemente uma função que aloque memória no Heap para uma matriz bidimensional triangular inferior.
```
int** new_ti_matrix(int n) { //ti = triangular inferior.
}
```
$\begin{bmatrix} \ell_{1,1} & & & & \\ \ell_{2,1} & \ell_{2,2} & & & \\ \ell_{3,1} & \ell_{3,2} & \ddots & & \\ \vdots & \vdots & \ddots & \ddots & \\ \ell_{n,1} & \ell_{n,2} & \ldots & \ell_{n,n-1} & \ell_{n,n} \end{bmatrix}$

Inicialize a matriz triangular com um determinado valor.

void fill_ti_matrix(int** matrix, int n, int valor) {

}

Desaloque a memória de uma matriz triangular inferior.
```
void free_ti_matrix(int** matrix, int n) {

}
```