Lista10

(1)

PONTEIROS Disciplina: PC-I

Exercício 1: Dado o Programa 1, completar as Tabelas 1 e 2: Programa 1 main() { int i, j, *p_1, *p_2, **p_p_1, **p_p_2; i = 4; j = 5; p_1 = &i; p_2 = &j; p_p_1 = &p_2; p_p_2 = &p_1; } Tabela 1 Nome Variável i j p_1 p_2 p_p_1 p_p_2 Conteúdo 4 5 Endereço 1000 1007 1030 1053 1071 1079 Tabela 2

Expressão i *p_2 &i &p_2 **p_p_1 *p_p_2 &*p_1 j *p_1 *&p_1

Resultado

Exercício 2: Dado o Programa 2, completar as Tabelas 3 e 4: Programa 2 main() { int i, j, *p_1, *p_2, **p_3, ***p_4; i = 4; j = 5; p_1 = &j; p_2 = &i; p_3 = &p_1; p_4 = &p_3; } Tabela 3 Nome Variável i j p_1 p_2 p_3 p_4 Conteúdo 4 5 Endereço 1000 1007 1030 1053 1071 1079

(2)

Tabela 4

Expressão i *p_2 &j &p_2 **p_3 **p_4 ***p_4 *p_1 *&p_2 *p_4 Resultado

Exercício 3: Dado o Programa 3, completar as Tabelas 5 e 6: Programa 3 main() { int i, j, *p_1, **p_2, **p_3, ***p_4; i = 4; j = 5; p_1 = &j; p_2 = &p_1; p_3 = p_2; p_4 = &p_3; } Tabela 5 Nome Variável i j p_1 p_2 p_3 p_4 Conteúdo 4 5 Endereço 1000 1007 1030 1053 1071 1079 Tabela 6

Expressão i *p_2 &j &p_2 **p_3 **p_4 ***p_4 *p_1 *&p_2 *p_4 Resultado

Exercício 4: Dado o Programa 4, completar as Tabelas 7 e 8: Programa 4 main() { int i, *p_1, *p_2, v[10]; p_1 = v; p_2 = p_1; for (i = 0; i < 10; i++) { v[i] = (2*i)+1; p_2++; } for (i = 0; i < 10; i++) { p_2--; printf(“ [%d] ”, *p_2); } }

Tabela 7 – Valores contidos no vetor v. Nome

Variável

v[0] v[1] v[2] v[3] v[4] v[5] v[6] v[7] v[8] v[9] v[10] Conteúdo

(3)

Valor de i 0 1 2 3 4 5 6 7 8 9 10 *p_2

Exercício 5: Dado o Programa 5, completar as Tabelas 9 e 10: Programa 5 main() { char i, *p_1, *p_2, v[10]; p_1 = v; p_2 = p_1; for (i = 0; i < 10; i++)

{ v[i] = char (2*i); p_2++; } for (i = 0; i < 10; i++)

{ p_2--; printf(“ [%d] ”, (int) (p_2 - p_1) ); } }

Variável

Endereço 5000

Tabela 10 – Valores impressos com: printf(“ [%d] ”, (int) (p_2 - p_1)). Valor de i 0 1 2 3 4 5 6 7 8 9 10 p_2 – p_1

Exercício 6: Dado o Programa 6, completar as Tabelas 11 e 12: Programa 6 main() { int i; double *p_1, *p_2, v[10]; p_1 = v; p_2 = p_1; for (i = 0; i < 10; i++) { v[i] = 1/(float(2*(i+1))); p_2++; } for (i = 0; i < 10; i++) { printf(“ [%p] ”, p_1); p_1++;} }

Variável

(4)

Tabela 12 – Valores impressos com o comando: printf(“ [%p] ”, p_1). Valor de i 0 1 2 3 4 5 6 7 8 9 10

p_1

Exercício 7: Mostrar os valores impressos pelo Programa 7 para n = 10: Programa 7

#include <stdlib.h> #include <stdio.h> #include <math.h> // Protótipos das funções.

void preencheV(float *V, int n); void printV(float *V, int n); main() { int i, n; float *p; printf(“Entre com n:”); scanf(“%d”, &n);

// Alocação dinâmica de n espaços de memória de tamanho sizeof(float). p = (float *) calloc(n, sizeof(float));

preencheV(p, n); printV(p, n);

// Liberação de memória dinâmica do vetor v cujo endereço // do primeiro elemento esta armazenado em p.

free(p); }

// Função que preenche o vetor v. void preencheV(float *V, int n) { int i;

*V = 4;

for (i = 1; i < n; i++) {

*(V+i) = *(V+i-1) + (4/float(2*i+1))*pow(-1,i); }

}

// Função que imprime o vetor v. void printV(float *V, int n) { int i;

for (i = 0; i < n; i++)

printf(“ V[%4d] = %8.6f \n”, i, V[i]); }

(5)

Programa 8 #include <stdlib.h> #include <stdio.h> // Protótipos das funções.

void preencheM(float **M, int m, int n); void printM(float **M, int m, int n); main()

{

int i, m, n; float **p;

printf(“Entre com m e n:”); scanf(“%d %d”, &m, &n);

// Alocação dinâmica de n espaços de memória de tamanho sizeof(float). p = (float **) calloc(m, sizeof(float *));

for (i = 0; i < m; i++)

p[i] = (float *) calloc(n, sizeof(float));

preencheM(p, m, n); printM(p, m, n);

// Liberação de memória dinâmica do vetor cujos elementos são // endereços de outros vetores e cujo endereço do primeiro // elemento esta armazenado em p.

for (i=0; i < m; i++) free(p[i]);

free(p); }

// Função que preenche a matriz M. void preencheM(float **M, int m, int n) { int i, j;

for (i = 0; i < m; i++) for (j = 0; j < n; j++)

*(*(M+i)+j) = *(*(M+i)+j) + i + j; }

// Função que imprime a matriz M. void printM(float **M, int m, int n) { int i, j; for (i = 0; i < m; i++) { for (j = 0; j < n; j++) printf(“ [%8.6f] ”, M[i][j]); printf(“\n”); } }

(6)

Exercício 9: Empregando a alocação dinâmica de memória descrita no Programa 8 fornecido no Exercício 8, construir um trecho de código que realize a soma de duas matrizes A e B de dimensões m x n e m x n, respectivamente, e armazena o resultado em uma matriz C e depois imprime C. Os elementos das matrizes A e B são valores gerados aleatoriamente no intervalo [1, 6] e [7, 12], respectivamente. As matrizes A, B e C são alocadas dinamicamente.

Exercício 10: Empregando as alocações dinâmicas de memória descritas no Programas 7 e 8, construir um trecho de código que realize a multiplicação de uma matriz A de dimensão m x k por um vetor v de dimensão k x 1 e armazene o resultado em um vetor r de dimensão m x 1. A matriz A e o vetor v devem ter valores gerados aleatoriamente nos intervalos [4, 7] e [0, 1], respectivamente. A matriz A e os vetores v e r devem ser alocados dinamicamente.

Exercício 11: Empregando a alocação dinâmica de memória descrita no Programa 8, construir um trecho de código que realize a multiplicação de uma matriz A por uma matriz B e armazene o resultado em uma matriz C. Os elementos das matrizes A e B são valores gerados aleatoriamente no intervalo [1, 10] e [0, 1], respectivamente. As matrizes A, B e C são alocadas dinamicamente.

Exercício 12: Crie e teste a função void Troca3(int a, int b, int c) que retorna a = c, b = b e c = a. Dica: Uma forma de resolver o problema é construir uma função auxiliar void TrocaAux(int k1, int k2) que troca os valores das variáveis k1 e k2, e na função Troca3 realizar chamadas à função TrocaAux.

Exercício 13: Crie e teste a função void Ord3(int a, int b, int c) que devolve em ordem crescente os valores contidos em a, b e c. Por exemplo, se a = 5, b = 4 e c = 3, após a chamada a função Ord3, a = 3, b = 4 e c = 5.

Exercício 14: Crie e teste a função void InverteS(char *s) que retorna uma string invertida. Por exemplo, se s = “Palindromo”, após a chamada a função InverteS, s = “omordnilaP”.

Exercício 15: Criar um tipo CONTA que representa a conta corrente de um dado cliente de um Banco. O tipo CONTA deve possuir os seguintes campos:

• Nome – Nome do correntista.

• NumCC – Número da conta corrente (sem traço). Para testar este novo tipo realize as seguintes tarefas:

(A) Criar uma função CONTA fillConta(CONTA C1) que preenche os campos da variável C1, do tipo CONTA, com informações de um dado correntista.

(7)

relativos aos campos de uma variável C1 do tipo CONTA.

(C) Testar as funções desenvolvidas nos itens anteriores através do programa principal que realiza as seguintes ações:

(C.1) Criar um vetor V do tipo CONTA de tamanho n determinado em tempo de execução.

(C.2) Empregar um laço para preencher os elementos de V através da função fillConta.

(C.3) Mostrar cada um dos elementos de V com um laço que chama a função mostraConta.

Exercício 16: Criar um tipo Aluno e um tipo Materia tal como dado abaixo: typedef struct Aluno

{ int matricula;

float *vNotas; // Armazena as 5 notas de um aluno ao longo de um ano. char nome[100];

}Aluno;

typedef struct Materia

{ Aluno *V; // Armazena a informação de n alunos !! float media[5]; // Armazena as 5 médias do ano.

int nAlunos // Número de alunos matriculados no curso. }Materia;

(A) Criar uma função Aluno fillAluno(Aluno a1) que preenche os campos de uma variável a1 do tipo Aluno e retorna essa variável preenchida.

(B) Criar uma função Materia fillMateria(Materia m1, int numAlunos) que preenche os campos de uma variável m1 do tipo Materia realizando chamadas a função fillAluno em um número de vezes igual ao número contido na variável numAlunos.

(C) Criar uma função int mediaMateria(Materia m1) que fornece a média de cada prova do ano para os alunos contidos na variável m1 e assim preenche o campo media de m1.

(D) Criar uma função void mostraMateria(Materia m1) que mostra as informações dos alunos contidas na variável m1.

(E) Criar um programa que ilustra o funcionamento das funções anteriores. Para tanto, o programa deve possuir uma variável pc1 do tipo Materia com 4 alunos. Depois, serão utilizadas as seguintes funções: fillMateria (que emprega fillAluno), mediaMateria e mostraMateria.

(8)

Exercício 17: Criar um tipo Livro e um tipo Biblioteca tal como dado abaixo: typedef struct Livro

{ int ano;

char titulo[100]; char autor[100];

int nVolume; // Número de exemplares de um dado livro. float preco;

}Livro;

typedef struct Biblioteca

{ Livro *V; // Armazena a informação de n livros !! int nLivros // Número de livros existentes na biblioteca. }Biblioteca;

(A) Criar uma função Livro fillAluno(livro l1) que preenche os campos de uma variável l1 do tipo Livro e retorna essa variável preenchida.

(B) Criar uma função Biblioteca fillBiblioteca(Biblioteca b1, int numLivros) que preenche os campos de uma variável b1 do tipo Biblioteca realizando chamadas a função fillLivro em um número de vezes igual ao número contido na variável numLivros.

(C) Criar uma função int valorBiblioteca(Biblioteca b1) que fornece o montante gasto para se comprar todos os exemplares existentes na biblioteca.

(D) Criar uma função int maiorBiblioteca(Biblioteca b1) que fornece o livro com maior número de exemplares existente na variável b1.

(E) Criar um programa que ilustra o funcionamento das funções anteriores. Para tanto, o programa deve possuir uma variável feg do tipo Biblioteca com 4 livros (1 livro de ALCV, 1 de PC-I, 1 de Cálculo I e 1 de Física I). Depois, serão utilizadas as seguintes funções: fillBiblioteca (que emprega fillLivro), valorBiblioteca e maiorBiblioteca.