Parte IV

Tópicos Especiais em Sistemas Computacionais
Leandro Soares de Sousa (DSc.)
e-mail: leandro.uff.puro@gmail.com
Página: http://www.ic.uff.br/~lsousa
Parte IV
Ferramentas para ajudá-los no mestrado! 2
● Coisas do sistema
Operacional:
UNIX → LINUX!
Coisas do sistema operacional (UNIX/LINUX) 3
● Vamos explorar algumas interações com o Sistema

Operacional.
● getpid() – retorna o process ID do processo que chama a
função
● PPID / KILL -<sinal> PID / KILL -<sinal> -PID
● COMANDO &
● nohup COMANDO & (vamos testar!)
● COMANDO ; COMANDO
● stddin / sdtout / stderr
● /dev/null / 1 / 2 / > / >> / <
● PIPE: comado | comando
● sleep(segundos)
● usleep(micro segundos) para mili x 1000
● Instrução C: system(“COMANDO”);
● Usando o que aprendemos!

● Um programa que controla a execução de outro!
● para.c: recebe como parâmetro um inteiro, salva seu pid
e parâmetro, espera por seu conteúdo em segundos e
sai.
● controla.c: dispara uma série de “para.c”, lê o conteúdo
do arquivo gerado por eles e verifica a execução.
● para.c: recebe como parâmetro um inteiro, salva seu pid

e parâmetro, espera por seu conteúdo em segundos e
sai.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv)
{
FILE *arq;
if (argc != 2){printf("\nERRO: para <tempo>\n");return(1);}
arq = fopen("t.txt","at");
fprintf(arq,"%d;%d\n",getpid(),atoi(argv[1]));
fflush(arq);
fclose(arq);
printf("Sou %d e vou dormir %d segundos\n",getpid(),atoi(argv[1]));
sleep(atoi(argv[1]));
printf("Sou %d e dormi %d segundos\n",getpid(),atoi(argv[1]));
return(0);
}

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int mpid[5],mtempo[5],i;
int mpara[5] = {20,30,40,50,60};
int final[5] = { 0, 0, 0, 0, 0};
int ainda_tem = 5;
char linha[100];
FILE *arq;
for (i = 0 ; i < 5 ; ++i)

{
sprintf(linha,"./para %d &%c",mpara[i],(char)('\0'));
system(linha);
sleep(1);
}

arq = fopen("t.txt","rt");
for (i = 0 ; i < 5 ; ++i)
{
fscanf(arq,"%d;%d\n",&(mpid[i]),&(mtempo[i]));
}
fflush(arq);
fclose(arq);

while (ainda_tem>0){
for (i = 0 ; i < 5 ; ++i){
if (!final[i]){
sprintf(linha,"ps p %d -o comm= >>/dev/null ;
echo $? > res.txt%c",mpid[i],(char)('\0'));
system(linha);
sleep(1);
arq = fopen("res.txt","rt");
if (((char)fgetc(arq)) != ((char)('0'))){
printf("O %d que dormiu %d segundos acabou!
\n",mpid[i],mtempo[i]);
--ainda_tem; final[i] = 1;
} // if
fclose(arq);
} // if
} // for
} // while
printf("\nTerminaram todos!\n");
return(0);} // main()
● Tratamento dos sinais emitidos pelo

Sistema Operacional!
Tratamento dos sinais emitidos pelo SO! 11
● O sistema operacional emite sinais que podem

interromper a execução de um programa, alguns
necessários e outros podem ser tratados
● Os que podem ser tratados podem evitar, por exemplo,
um ctrl+C
EliminarSinais()
{
int i;
for (i = 0 ; i <= 7 ; ++i){signal(i,SIG_IGN);}
signal(21,SIG_IGN);
return;
}
// int kill(pid_t pid, int sig);

● Programa exemplo para tratar o sinal 10 (sinal.c)!

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <signal.h>
#include <sys/types.h>
#include <errno.h>
#define M_SIGNAL 10
void rotina_qualquer(void)
{
FILE *arq;
arq = fopen("./ex.txt","at");
fprintf(arq,"Escrevi (%ld)\n",time(NULL));
fflush(arq);fclose(arq);
return;
}
void tratar_sinal_de_parada(int a)
{
printf("Sinal %d\n",a);
rotina_qualquer();
signal(M_SIGNAL,tratar_sinal_de_parada);
return;
}
int main(void)
{
signal(M_SIGNAL,tratar_sinal_de_parada);
for (;;)
{
sleep(10);
}
return(0);
}
● Medição fina de tempo!

Medição fina de tempo 16
● Medição fina de tempo em nanosegundos e em

milissegundos (tempo.c)!
// compilar ==> gcc -o tempo tempo.c -lrt
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
// para o ftime em milisegundos

#include <sys/types.h>
#include <sys/timeb.h>
// para o clock_gettime em nanosegundos

#include <time.h>
// para as definições de erro

#include <errno.h>
void funcionalidade()
{
int i,n = 0;
for(i = 0 ; i < 4 ; i++)
{
n+=i;
printf("executando sleep %d\n",i);
sleep(1);
}
printf("\n");
return;
}
int main()
{ struct timespec ti1,tf1; // nanosegundos
struct timeb ti2,tf2; // milissegundos
// nanosegundos
printf("TEMPO EM NANO SEGUNDOS:\n\n");
capturar_tempo_nanosegundos(&ti1);
funcionalidade();
capturar_tempo_nanosegundos(&tf1);
printf("Tempo ini (s): %ld\n",(long)ti1.tv_sec);
printf("Tempo ini (ns): %ld\n",(long)ti1.tv_nsec);
printf("Tempo fim (s): %ld\n",(long)tf1.tv_sec);
printf("Tempo fim (ns): %ld\n",(long)tf1.tv_nsec);
printf("Tempo Med (ns): %lld\n\n",
(((long long)tf1.tv_sec*(long long)(1000000000))+
((long long)tf1.tv_nsec))-(((long long)ti1.tv_sec*
(long long)(1000000000)) +((long long)ti1.tv_nsec)));
// milisegundos (aproximado)
printf("TEMPO EM MILI SEGUNDOS:\n\n");
capturar_tempo_milissegundos(&ti2);
funcionalidade();
capturar_tempo_milissegundos(&tf2);
printf("Tempo ini (s): %ld\n",(long)ti2.time);
printf("Tempo ini (ms): %ld (aproximado)\n",(long)ti2.millitm);
printf("Tempo fim (s): %ld\n",(long)tf2.time);
printf("Tempo fim (ms): %ld (aproximado)\n",(long)tf2.millitm);
printf("Tempo (ms): %ld\n",(((long)tf2.time*1000)+
(long)tf2.millitm) -
(((long)ti2.time*1000)+
(long)ti2.millitm));
return(0);
}
void capturar_tempo_nanosegundos(struct timespec *t){

if (clock_gettime(CLOCK_REALTIME,t))
{ switch(errno){
case EFAULT: printf("\nEFAULT tp points outside
the accessible address space.\n");
break;
case EINVAL: printf("\nEINVAL The clk_id specified
is not supported on this system.\n");
break;
case EPERM: printf("\nEPERM clock_settime() does not
have permission to set the clock
indicated.\n");
break;
default: printf("\nErro indefinido %d\n",errno);
}
exit(1);
}
return;
}
void capturar_tempo_milissegundos(struct timeb *t)

{
if (ftime(t))
{
printf("\nErro indefinido %d\n",errno);
exit(1);
}
return;
}
Parte IV - Continua
Uma breve revisão do “C” 23
● Tipo → Extensão em bits:
● char → 8
● int → 16
● short int → 16
● long int → 32
● float → 32
● short float → 32
● long float → 64
● double → 64
● short double → 64
● long double → 80
● Tipo → Extensão em bits → Escala
● char → 8 → -128 a 127

● int → 16 → -31768 a 32767
● float → 32 → 3.4E-38 a 3.4E+38
● double → 64 → 1.7E-308 a 1.7E308
● void → 0 → sem valor
● Type cast
● Pode-se forçar o compilador a efetuar

determinada conversão utilizando-se um type
cast que tem a seguinte forma:
(tipo) expressão
main() /* alerta sobre os parêntesis */

{
int x = 3;
printf(“%f %f\n”, (float) x / 2, (float) (x / 2));
/* serão impressos na tela 1.5 e 1.0 pois no primeiro
caso, x é convertido para float e depois é dividido, já
no segundo, somente o resultado é convertido para float
*/
}
● Operador → Ação
● - → subtração, também menos unário

● + → adição
● * → multiplicação
● / → divisão
● % → resto da divisão
● -- → decremento
● ++ → incremento
● > → maior que

● >= → maior ou igual a
● < → menor que
● <= → menor ou igual a
● == → igual a
● != → não igual a
● && → AND
● || → OR
● ! → NOT
● O operador = é o operador de atribuição. Ao

contrário de outras linguagens, C permite que o
operador de atribuição seja usado em expressões
com outros operadores.
int a, b, c;
a = b = c = 1; /* atribui 1 às 3 variáveis */
if ((a = 2 * b) > c) /* a = 2 e a comparação
resulta em 1 */
● Uma declaração de variável deve seguir a

seguinte regra:
tipo lista_variáveis;
● onde tipo deve ser um tipo válido em C e

lista_variáveis pode consistir em um ou mais
identificadores separados por vírgula.
int i = 0, j, l;
short int si;
unsigned int ui;
long inteiro_grande;
long long inteiro_muito_grande;
double balanco, lucro, prejuizo;
● Declaração de variável: onde?
/* soma os números de 1 a N */
int soma; /* Variável global */
soma_de_1_a_N(int N) /* Variável por parâmetro */
{
int cont; /* Variável local */
soma = 0; /* inicializa variável soma */
for (cont = 1; cont <= N; ++cont)
{
soma += cont;
}
printf("\nSoma de 1 a %d = %d\n,N,soma);
Return;
}
● Uma string é um conjunto de caracteres entre

aspas. Por exemplo, “esta é uma string” é uma
string. Não confundir strings com caracteres,
‘a’ é um caracter enquanto “a” é uma string.
● Existem alguns caracteres que não podem ser

representados no texto comum, as constantes com
barra invertida servem para representar estes
caracteres.
● Código → Significado
● \b retrocesso
● \f avanço de página
● \n mudança de linha
● \r retorno de carro
● \t tab horizontal
● \” aspas duplas
● \’ aspas simples
● \0 ASCII 0
● \\ barra invertida
● \v tab vertical
● \a alerte (beep)
● \x constante hexadecimal
● Funções úteis:
● A família printf:
● Rotina de finalidade geral para saída pelo

console
● A função printf() serve para mostrar mensagens

na tela. Sua forma geral é:
● printf(“string de controle”, lista argumentos);

● Rotina de finalidade geral para saída pelo
console
● A função printf() serve para mostrar mensagens
na tela. Sua forma geral é:
● printf(“string de controle”, lista argumentos);
● A string de controle consiste em dois tipos de

itens:
● Caracteres que a função imprimirá na tela
● Comandos de formatação
● Todos os comandos de formatação começam por %
que é seguido pelo código de formatação
● Deve haver exatamente o mesmo número de

argumentos quanto forem os comandos de
formatação e eles devem coincidir em ordem
● Código → Formato
● %c um único caracter
● %d decimal
● %i decimal
● %e notação científica
● %f ponto decimal flutuante
● %s string de caracteres
● %u decimal sem sinal
● %% sinal %
● sprintf(variavel_string,“string de controle”, lista
argumentos);
● fprintf(variavel_arquivo,“string de controle”, lista
argumentos);
● A família scanf:
● Rotina de finalidade geral para entrada pelo
console
● A função scanf() serve para ler informações do
teclado.
● Sua forma geral é:
● scanf(“string de controle”, lista argumentos);
● A ideia geral é a mesma do printf, mas a lista

de argumentos deve ser constituída por
ponteiros, para o armazenamento dos dados
lidos.
● A família scanf:
● Exemplo:
● scanf(“%d”, &cont);
● Como strings são representadas por vetores,
NÃO deve ser colocado o & antes do nome da
variável
● Também inclui:
● sscanf(variavel_string,“string de controle”, lista
argumentos);
● fscanf(variavel_arquivo,“string de controle”, lista
argumentos);
● Arquivos:
● Estrutura:
● FILE *arq;
● Abertura:
● fopen(path,”string abertura”);
● Retorna: (FILE *) (NULL) → ERRO c.c. ponteiro
para o arquivo
● String abertura:
● r → leitura
● w → escrita
● a → append
● + → possibilita a movimentação do ponteiro

(não obrigatoriamente sequencial)
● t ou b → para texto ou binário
● Arquivos:
● Despejar o arquivo:
● fflush(arq); fflush(stdout);
● Fechar:
● fclose(arq);
● Remoção:
● remove(path);
● Fim de arquivo:
● feof(arq); /* Verdadeiro se estiver no final
do arquivo. */
● Arquivos (leitura/escrita):
● Já vistas → fprintf e fscanf
● Linha texto:
● fgets(char *s, int tamanho, FILE *arq);
● Se OK retorna o ponteiro para s ou (char *) (NULL)
● Preserva o '\n'
● fputs(char *s, FILE *arq);
● Imprime em arq até o NULL ('\0')
● Retorna EOF em erro
● Caractere:
● fgetc(arq); /* retorna o caractere ou EOF em erro */
● fputc(inc c, arq); /* retorna o caractere ou EOF em
erro */
● Arquivos (leitura/escrita):
● Buffer binário:
● size_t fread(void *ptr, size_t size, size_t
nmemb, FILE *stream);
● size_t fwrite(const void *ptr, size_t size,

size_t nmemb, FILE *stream);
● Retorna o número de itens lidos ou zero em

caso de erro.
● Exemplo: ((void *)v,sizeof(int),200,arq) →
vetor v de 200 inteiros
● Arquivos (posicionamento):
● Buffer binário:
● int fseek(FILE *arq, long offset, int
whence);
● whence:
● SEEK_SET: do início
● SEEK_CUR: da posição corrente
● SEEK_END: do final do arquivo
● rewind(FILE *arq) é igual a fseek(arq, 0L, SEEK_SET);

Parte IV – Continua
Funções para manipulação de

strings.
Vetores, matrizes, estruturas.
● strings:
● memset((void *) a, int v, int qtd) → coloca
qtd vs em a.
● strcpy(a,b) → a recebe b (cuidado: limpem b
antes.
● strcat(a,b) → a + b
● strlen(a) → tamanho de a até o '\0'
● strcmp(a,b) e strncmp(a,b,n) → compara a com b
ou n primeiros caracteres de a com b.
● <0 a < b
● 0 a == b
● >0 a > b
● Estruturas:
● Em C, uma estrutura é uma coleção de variáveis

que são referenciadas pelo mesmo nome.
● É uma forma conveniente de manter juntas
informações relacionadas.
● Forma geral:
struct nome_estrutura {
tipo1 var1;
tipo2 var2;
} var_estrutura;
● Estruturas:
● Além de poder declarar variáveis do tipo da

estrutura durante a definição da estrutura, elas
podem ser declaradas da seguinte forma:
struct nome_estrutura nome_variável;
● Para acessar variáveis do tipo estrutura,

utiliza-se o operador . (ponto).
● Forma geral:
nome_variavel.nome_elemento;
● Estruturas:
● Exemplo:
struct pessoa {
char nome[21];
int idade;
} primeiro;
main() {
struct pessoa segundo;
strcpy(primeiro.nome, “José”);
primeiro.idade = 20;
segundo = primeiro;
}
● Estruturas:
● Podem ser declarados vetores e matrizes de

estruturas, para isto, usamos a forma geral:
struct nome_estrutura nome_var[t1][t2]...[tn];
● Exemplo:
struct pessoa pessoas[5];

● Estruturas:
● Fazer chamada por referência para uma função;
● Criar listas ligadas com estruturas dinâmicas de

dados usando o sistema de alocação.
● É mais rápido passar estruturas grandes por

referência (usando ponteiros) do que por valor,
pois estamos passando apenas um endereço.
● Estruturas:
● Veja a declaração:
struct pessoa *primeiro, segundo;

strcpy(segundo.nome, “José”);
segundo.idade = 10;
primeiro = &segundo;
● Para acessar o campo idade de primeiro:
(*primeiro).idade
primeiro -> idade
● Estruturas:
● Os elementos das estruturas podem ser simples ou

complexos, assim, podemos colocar vetores,
matrizes e até estruturas dentro das estruturas.
● Veja:
struct complexa {
char setor[21];
struct pessoa funcionarios[50];
}
● Estruturas:
● Os elementos das estruturas podem ser simples ou

complexos, assim, podemos colocar vetores,
matrizes e até estruturas dentro das estruturas.
● Veja:
struct complexa {
char setor[21];
struct pessoa funcionarios[50];
}
● Estruturas:
● Para evitar o “struct” na declaração da variável

podemos usar o typedef.
● Forma geral:
typedef tipo novo_tipo;
● Exemplos:
typedef int inteiro;
typedef struct pessoa {
char nome[21];
int idade;
} TIPO_pessoa;
● Declaração de variável
Inteiro i;
TIPO_pessoa funcionario; /*ou*/
struct pessoa funcionario;
● Vetores:
● Vetores são uma coleção de variáveis do mesmo

tipo que são referenciadas pelo mesmo nome.
● Em C, um vetor consiste em locações contíguas de

memória.
● O elemento mais baixo corresponde ao primeiro

elemento e o mais alto ao último.
● O vetor mais utilizado é o de caracteres.

● Vetores:
● A forma geral da declaração de um vetor é:
tipo nome_var[tamanho];
● Onde
● tipo é o tipo base do vetor e

● tamanho é a quantidade de elementos que o vetor
conterá
● Vetores:
● Os vetores são acessados através de índices

colocados entre colchetes.
● O índice do primeiro elemento do vetor é 0

(ZERO).
int amostra[10]; /* vetor de 10 inteiros */

amostra[0] /* primeiro elemento */
amostra[9] /* último elemento */
● Vetores:
● Exemplo:
main()
{
int x[10]; /* vetor com 10 elementos int */
int t;
for (t = 0; t < 10; t ++)
x [ t ] = t;
}
● Vetores:
● C não faz checagem dos limites dos vetores, isto

é responsabilidade do programador. Logo, o
código a seguir não causará nenhum erro (talvez
de execução).
int elementos[10];
elementos[12] = 0;
elementos[10] = 0;
● Matrizes:
● C permite que sejam declaradas matrizes

bidimensionais.
● Forma da declaração:
tipo nome_var[dimensão1][dimensão2];
● Exemplo:
char tabela[5][5];
● Matrizes:
● De forma semelhante as matrizes bidimensionais,

declaramos as multidimensionais.
● Veja por exemplo uma matriz de 4 dimensões:
int matriz[5][7][3][8];
● Matrizes:
● Exemplo:
main()
{
int numeros[4][3], i, j;
for (i = 0; i < 4; i ++)
for (j = 0; j < 3; j++)
numeros[ i ][ j ] = i * j;
}
● Matrizes:
● Uma matriz bidimensional de caracteres pode ser

interpretada como uma matriz de strings.
main()
{
char strings[5][20]; /* 5 strings */
int i;
for (i = 0; i < 5; i ++)
gets(strings[ i ]);
}
● Matrizes:
● C permite que as matrizes sejam inicializadas.
● A forma geral é:
tipo nome_matriz[tam1]...[tamN] = {lista de

valores}
● Exemplo:
int i[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int a[2][3] = { (1, 2}, {3, 4}, {5, 6}};

● Matrizes:
● Podem ser declarados vetores sem especificar

explicitamente seus tamanhos. Os vetores devem
ser inicializados na declaração. O tamanho será
definido na inicialização.
● Exemplo:
char mensagem[ ] = “Esta é uma string”;

char *mensagem = “Esta é uma string”;
● Ponteiros:
● Entender e usar corretamente os ponteiros são

pontos cruciais para criação de programas bem-
sucedidos em C.
● Além dos ponteiros serem uma das características

mais fortes em C, também é a mais perigosa.
● É muito fácil usar ponteiros incorretamente

causando erros difíceis de serem encontrados.
● Ponteiros:
● Os ponteiros fornecem maneiras pelas quais as

funções podem modificar os argumentos recebidos.
● Dão apoio às rotinas de alocação dinâmica.
● Podem substituir o uso vetores em muitas

situações para aumentar a eficiência.
● Ponteiros:
● Um ponteiro é uma variável que contém um

endereço de memória. Isto é, eles possuem
armazenam a localização de outra variável dentro
da memória do computador.
● Então dizemos que um ponteiro aponta para esta

variável.
● Ponteiros:
● A declaração de variáveis ponteiros, segue a

seguinte regra geral:
tipo *nome_var;
onde tipo é o tipo do elemento para o qual o

ponteiro apontará.
Exemplo:
char *p;
int *temp, *valor;
● Ponteiros:
● Exemplo:
main()
{
int numero = 5, *p;
p = &numero;
printf(“%d %d\n”, numero, *p);
*p = 3;
printf(“%d %d\n”, numero, *p);
}
● Ponteiros:
● C permite que sejam feitas expressões com

ponteiros e elas seguem as mesmas regras das
outras expressões em C.
● Quando se compara um ponteiro com outro, estamos

comparando seus endereços. Isto é útil quando
ambos os ponteiros apontam para elementos de um
vetor.
● Ponteiros:
● Existe um relacionamento muito próximo entre os

ponteiros e os vetores.
● Veja o código:
char str[80], *p;

p = str;
● Este código faz com que p aponte para o primeiro

elemento do vetor, pois um vetor sem o índice se
comporta como um ponteiro para seu primeiro
elemento.
● Ponteiros:
● Após a definição:
char str[80], *p;

p = str;
● são equivalentes os acessos ao quinto elemento

de str:
str[4]
*(p + 4)
p[4]
● ++p p++ movimenta o ponteiro dentro do tipo dele

● Ponteiros:
/* este programa está errado */
main()
{
int x, *p;
x = 10;
*p = x;
}
/* este programa está errado */
main()
{
int x, *p;
x = 10;
p = x;
printf(“%d”, *p);
}
Parte IV – FIM

Parte IV

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Parte IV

Enviado por

Direitos autorais:

Formatos disponíveis

Tópicos Especiais em Sistemas Computacionais

Leandro Soares de Sousa (DSc.)

● Vamos explorar algumas interações com o Sistema

● Usando o que aprendemos!

● para.c: recebe como parâmetro um inteiro, salva seu pid

● controla.c: dispara uma série de “para.c”, lê o conteúdo

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

● controla.c: dispara uma série de “para.c”, lê o conteúdo

● controla.c: dispara uma série de “para.c”, lê o conteúdo

● Tratamento dos sinais emitidos pelo

● O sistema operacional emite sinais que podem

for (i = 0 ; i <= 7 ; ++i){signal(i,SIG_IGN);}

for (i = 15 ; i <= 17 ; ++i){signal(i,SIG_IGN);}

for (i = 23 ; i <= 32 ; ++i){signal(i,SIG_IGN);}

// int kill(pid_t pid, int sig);

● Programa exemplo para tratar o sinal 10 (sinal.c)!

● Medição fina de tempo!

● Medição fina de tempo em nanosegundos e em

// compilar ==> gcc -o tempo tempo.c -lrt

// para o ftime em milisegundos

// para o clock_gettime em nanosegundos

// para as definições de erro

void capturar_tempo_nanosegundos(struct timespec *t){

void capturar_tempo_milissegundos(struct timeb *t)

● Tipo → Extensão em bits:

● Tipo → Extensão em bits → Escala

● char → 8 → -128 a 127

● Pode-se forçar o compilador a efetuar

main() /* alerta sobre os parêntesis */

● - → subtração, também menos unário

● > → maior que

● O operador = é o operador de atribuição. Ao

● Uma declaração de variável deve seguir a

● onde tipo deve ser um tipo válido em C e

● Declaração de variável: onde?

● Uma string é um conjunto de caracteres entre

● Existem alguns caracteres que não podem ser

● Rotina de finalidade geral para saída pelo

● A função printf() serve para mostrar mensagens

● printf(“string de controle”, lista argumentos);

● A string de controle consiste em dois tipos de

● Deve haver exatamente o mesmo número de

● A ideia geral é a mesma do printf, mas a lista

● Retorna: (FILE *) (NULL) → ERRO c.c. ponteiro

● + → possibilita a movimentação do ponteiro

● size_t fwrite(const void *ptr, size_t size,

● Retorna o número de itens lidos ou zero em

● SEEK_CUR: da posição corrente

● SEEK_END: do final do arquivo

● rewind(FILE *arq) é igual a fseek(arq, 0L, SEEK_SET);

Funções para manipulação de

● Em C, uma estrutura é uma coleção de variáveis

● Além de poder declarar variáveis do tipo da

struct nome_estrutura nome_variável;

● Para acessar variáveis do tipo estrutura,

● Podem ser declarados vetores e matrizes de

struct nome_estrutura nome_var[t1][t2]...[tn];

struct pessoa pessoas[5];

● Fazer chamada por referência para uma função;

● Criar listas ligadas com estruturas dinâmicas de

● É mais rápido passar estruturas grandes por

struct pessoa *primeiro, segundo;

● Para acessar o campo idade de primeiro: