"Até das nuvens mais negras cai água límpida e fecunda" (provérbio chinês)

" Se você não pode vencer pelo talento, vença pelo esforço "
Um dia eu ainda irei ajudar como muitos que me ajudam atualmente...

Introdução à Programação C

Exemplo de um Programa
// Exemplo de programa em C
// Isto é uma linha de
comentário
void main()
{
int a; //
declara a variável "a"
a = 3 + 2; // soma
3 com 2
}

• Um programa em C é composto por um conjunto de Funções. A função pela qual

o programa começa a ser executado chama-se main.

• Após cada cada comando em C deve-se colocar um ; (ponto-e-vírgula).

• Um programa em C deve ser Identado para que possa ser lido com mais
facilidade.

Identificadores
São os nomes que podem ser dados para variáveis e funções.
Para a escolha destes nomes é necessário seguir alguams regras:

• Um identificador deve iniciar por uma letra ou por um "_" (underscore);

• A partir do segundo caracter pode conter letras, números e underscore;

• Deve-se usar nomes significativos dentro do contexto do programa;

• C é uma linguagem case-sensitive, ou seja, faz diferença entre nomes com letras
maiúsculas e nomes com letras minúsculas. Peso e peso são diferentes;

• Costuma-se usar maiúsculas e minúsculas para separar palavras:

"PesoDoCarro";

• Deve ser diferente dos comandos da linguagem;

 • Deve ter no máximo 31 caracteres (no caso do TurboC);

• Pode conter números a partir do segundo caracter;

• Exemplos:
Idade, Contador, PesoDoCarro,
Usuario_1, CorDaPagina, RaioDoCirculo

Variáveis
Uma variável é uma possição de memória que pode ser identificada através de um nome.
Podem ter seu conteúdo alterado por um comando de atribuição.
Após a atribuição mudam de valor.
int a,b, SomaGeral;
a = 3; // a recebe o valor 3
b = a * 2; // b recebe o dobro do valor de a
c = a + b + 2; // c recebe 11

Tipos de Variáveis
• Todas as variáveis em C tem um tipo;

• Cada tipo define os valores que a variável pode armazenar;

• Cada tipo ocupa uma certa quantidade de nemória.

Tipo Tamanho Valores Válidos
char 1 byte letras e símbolos: 'a', 'b', 'H', '^', '*','1','0'
int 2 bytes de -32767 até 32767 (apenas números inteiros)
float 4 bytes de -3.4 x 1038 até +3.4 x 10+38com até 6 dígitos de precisão
double 8 bytess de -1.7 x 10308 até +1.7 x 10+308com até 10 dígitos de precisão

Declaração de Variáveis
• Todas as variáveis tem que ser declaradas antes de serem usadas;

• Não há uma inicialização implícita na declaração

// Exemplo de programa em C

#include <stdio.h> //
Arquivo de cabeçalho
(header)
void main()
{
 int
contador; //
declarações simples
float PrecoDoQuilo;
double TaxaDeCambio;
char LetraDigitada;
int IdadeManoel,
IdadeJoao, IdadeMaria; //
Pode colocar mais de uma
variável na

// na
mesma linha
double TaxaDoDolar,
TaxaDoMarco,
TaxaDoPeso,
// Também pode trocar de
linha no meio
TaxaDoFranco;
.......
}

Inicialização de Variáveis na Declaração

// Exemplo de programa em C

#include <stdio.h> //
Arquivo de cabeçalho
(header)
void main()
{
int NroDeHoras = 0;
// declara e inicializa com
Zero
float PrecoDoQuilo =
10.53; // declara e
inicializa com 10.53
double TaxaDoDolar =
1.8,
TaxaDoMarco =
1.956,
TaxaDoPeso =
1.75,
TaxaDoFranco =
0.2;
.......
}

Constantes
Constantes são identificadores que não podem ter seus valores alterados durante a
execução do programa.
Para criar uma constante existe o comando #define que, em geral é colocado no início
do programa-fonte.
Exemplos
#define LARGURA_MAXIMA 50 // Não se coloca ponto-e-vírgula após o
valor
#define NRO_DE_DIAS_DA_SEMANA 7
#define NRO_DE_HORAS_DO_DIA 24
#define VALOR_DE_PI 3.1415
void main ()
{
int TotalDeHoras;

TotalDeHoras = 10 * NRO_DE_DIAS_DA_SEMANA * NRO_DE_HORAS_DO_DIA;

......
}

Strings
Uma String é uma seqüência de caracteres entre aspas duplas: "exemplo de uma string
em C".

A função printf
A função printf exibe um ou mais dados na tela. Para tanto ele deve receber pelo
menos dois parâmetros, separados por vírgula:

• um string de formato que define, através de caracteres especiais, os tipos dos

dados a serem impressos e suas posições na linha de impressão;

• um dado a ser impresso. Este dado pode ser qualquer um dos dados visto
anteriormente.
Por exemplo:
printf("%s","teste");

"%s" : é a string de formato

"teste" : é o dado a ser impresso.

A string de formato define quais os tipos dos dados a serem impressos. O símbolo %s
será substituído pelo dado que vem após a vírgula.
Os dados definem quais os valores a serem impressos.
Se for necessário, um string de formato pode definir que mais de um dado será impresso.
Para tanto, dentro da string de formato deve haver mais de um %, um para cada dado a
ser impresso.
Neste caso, os dados devem vir após a string de formato separados por vírgulas.
Por exemplo:
printf("%s %s","teste1", "outra string");

Isto irá imprimir o string teste1 deixar 1 espaço em branco e imprimir ao lado
 o string outra string, assim :
teste1 outra string
#include <stdio.h> // Necessário para usar a função printf
// A função printf exibe um ou mais dados na tela
void main ()
{
printf("%s","Isto é uma string ....\n"); // note o '\n' no final da
string;
printf("%s","Outra string ....");
printf("%s","Terceira string\n");
//Depois de Executar o programa, tecle ALT-F5 para ver o resultado na tela
}
Exercício
Experimente colocar um '\n' entre os %s na string de formato.
printf("%s\n%s","teste1", "outra string");

Inclusão de Texto na String de Formato

É possível incluir um texto dentro da string de formato. Este texto irá aparecer
exatamente como for digitado no programa-fonte.
O exemplo
printf("A aluna %s ficou doente","Maria");
geraria
A aluna Maria ficou doente
como resultado.

Constantes do tipo String

#define UNIVERSIDADE "Pontifícia Universidade Católica do Rio Grande do Sul"
// deve-se colocar entre aspas
#include <sdtio.h>
#include <conio.h> // necessário para as funções clrscr e getch
void main ()
{
clrscr(); // Limpa a tela
printf("%s", UNIVERSIDADE); // Imprime o nome representado pela constante
getch(); // espera que o usuário pressione uma tecla
}

Impressão de Inteiros com "printf"

Para imprimir um inteiro com printf usa-se o símbolo %d
// Impressão de Variáveis Inteiras
#include <stdio.h>
#include <conio.h> // necessário para as funções clrscr e getch
void main ()
{
 int Contador;
int NroDeFilhos;

clrscr(); // Limpa a tela

Contador = 10;
printf("Valor da Variável: %d\n", Contador); // No momento da
execução sinal %d vai
// ser substituído pelo valor
da
// variável Contador
NroDeFilhos = 3;
printf("Maria tem %d filhos", NroDeFilhos); // o inteiro pode ficar no
meio da string
getch(); // espera que o usuário pressione uma tecla
}

Impressão de Expressões aritméticas

// Impressão de Expressões aritméticas
#include <stdio.h>
#include <conio.h> // necessário para as funções clrscr e getch
void main ()
{
int NroDeAndares;
int AlturaPorAndar;

clrscr(); // Limpa a tela

NroDeAndares = 7;
AlturaPorAndar = 3;

printf("Altura Total do Prédio: %d metros", NroDeAndares*AlturaPorAndar);

// No momento da execução sinal %d vai ser substituído
// pelo valor da multiplicação
getch(); // espera que o usuário pressione uma tecla
}

Impressão de Números reais

// Impressão de números reais
#include <stdio.h>
#include <conio.h> // necessário para as funções clrscr e getch
void main ()
{
float NotaDaP1, NotaDaP2;
float Media;

clrscr(); // Limpa a tela

NotaDaP1 = 6.6; // Atribuição do Valores das médias
NotaDaP2 = 8.2;

Media = (NotaDaP1 + NotaDaP2) / 2.0;

printf("Média Final : %f", Media);

// No momento da execução sinal %f vai ser substituído
// pelo valor da variável Media com SEIS casas decimais
 // Média Final : 7.400000
getch(); // espera que o usuário pressione uma tecla
}

Formato de Impressão dos Números Reais

No exemplo acima o resultado da média (7.4) foi impresso com 6 casas decimais
(7.400000).
Isto sempre acontece quando se manda imprimir um float da forma como foi feito no
exemplo acima. Isto acontece pois o padrão da função printf é completar o número com
zeros à direita, até que fique com seis casas decimais.
Para formatar de maneira diferente usar-se, junto com o %f uma especificação de quantas
casas decimais se deseja que o número tenha. Especifica-se também o número total de
caracteres do número a ser impresso.
Por exemplo: %6.3f especifica que se quer imprimir um float com 3 casas decimais e
com um tamanho total de 6 caracteres no total.
#include <stdio.h>
#include <conio.h>
void main()
{
float NotaDaP1, NotaDaP2;
float Media;

clrscr(); // Limpa a tela

NotaDaP1 = 6.6; // Atribuição do Valores das médias
NotaDaP2 = 8.2;

Media = (NotaDaP1 + NotaDaP2) / 2.0;

printf("Média Final : %6.3f", Media);

// No momento da execução sinal %6.3f vai ser substituído
// pelo valor da variável Media
// Média Final : 7.400
getch(); // espera que o usuário pressione uma tecla

}
Regras para impressão de um número real

• o número de casas decimais é sempre respeitado. Se for preciso, zeros serão

acrescetados à direita do número

• o tamanho total significa o número de caracteres do número incluíndo o ponto

decimal e um eventual sinal de
menos (-), se for o caso;

• Se a soma do número de caracteres da parte inteira, mais o ponto decimal, mais

a parte fracionária, mais um eventual sinal de menos ainda for menor do que o
tamanho total especificado no formato, então, espaços em branco serão
acrescentados à esquerda da parte real do número.
 • Se a soma do número de caracteres da parte inteira, mais o ponto decimal, mais
a parte fracionária, mais um eventual sinal de menos for maior do que o
tamanho total especificado no formato, então, apenas o número de casas decimais
é respeitado
Por exemplo:
#include <stdio.h>
#include <conio.h>
void main()
{
float Numero;
Numero = -2.5;
clrscr();
printf("1234567890\n");
printf("%7f\n", Numero);
printf("%7.0f\n", Numero);
printf("%7.3f\n", Numero);
printf("%8.3f\n", Numero);
printf("%9.3f\n", Numero);
printf("\n");
printf("%8.4f\n", Numero);
printf("%8.1f\n", Numero);
printf("%6.12f\n", Numero);

getch();
}

// Resultados
1234567890
-2.500000
-2
-2.500
-2.500
-2.500

-2.5000
-2.5
-2.500000000000
Alinhamento de números à DIREITA
Nos exemplos anteriores os números ficavam sempre alinhados a partir da esquerda.
Experimente colocar um sinal de menos logo depois do sinal de % e veja o que acontece.
printf("%-7.3f\n", Numero);

Variáveis do Tipo String

Uma variável capaz de arrmazenar uma string deve ser declarada informando-se qual o
número máximo de caracteres que ela poderá armazenar.
Exemplo:
char Nome[30]; // isto define que a variável poderá armazenar
uma
// string de até 29 caracteres.
Ao trabalharmos com strings deve-se incluir o arquivo de cabeçalho string.h

Atribuição com strings

As atribuições de valores a strings devem ser feitas através da função strcpy
// Exemplo com strings
#include <stdio.h>
#include <conio.h>
#include <string.h> // arquivo de cabeçalho para trabalhar com strings

void main()
{
char Nome[30]; // declara uma string que poderá armazenar até 29
caracteres !!
clsrscr();
strcpy(Nome, "Jose da Silva"); // atribui "Jose da Silva" para a variável
Nome
printf("O funcionário %s foi tranferido", Nome); // no lugar de %s
aparecerá o
// conteúdo da variável
Nome
getch();
}

Operadores Aritméticos
-sinal de menos (unário) Maior precedência (avaliado ant
*,/multiplicação e divisão

%módulo (reto da divisão)

+,-soma e subtração Menor precedência (avaliado dep

Pode-se usar parênteses para alterar a precedência.
Exercício
Crie um progama que organize os dados em uma tabela conforme o exemplo a seguir. Os
dados das células em amarelo deve ser informados através de atribuições dentro do
programa.
Procure usar somente os %f para definir o formato e a posição dos dados.
Não tente preencher os espaços com brancos. Por exemplo, use
printf ("%10d, QuantidadeDeBananas);
ou invés de
printf(" %d", QuantidadeDeBananas);
Produto Preço Unitário Quantidade Preço Total
Banana R$ 2.50 2R$ 5.00
Uva R$ 6.50 6R$ 39.00
Pessego R$ 10.22 10R$ 102.20
Sub-Total R$ 146.20
Imposto (5%) R$ 7.31

Total R$ 153.51

Ponteiro (programação)
Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Nota: Se procura pelo objeto para indicar sentidos, consulte Ponteiro.
Em programação, um ponteiro ou apontador é um tipo de dado de uma linguagem de
programação cujo valor se refere diretamente a um outro valor alocado em outra área da
memória, através de seu endereço. Um ponteiro é uma simples implementação do tipo
referência da ciência da computação.

Arquitetura
Ponteiros são uma abstração da capacidade de endereçamento fornecidas pelas
arquiteturas modernas. Em termos simples, um endereço de memória, ou índice
numérico, é definido para cada unidade de memória no sistema, no qual a unidade é
tipicamente um byte ou uma word, o que em termos práticos transforma toda a memória
em um grande vetorHYPERLINK \l "cite_note-0"[1]. Logo, a partir de um endereço, é
possível obter do sistema o valor armazenado na unidade de memória de tal endereço. O
ponteiro é um tipo de dado que armazena um endereço.
Na maioria das arquiteturas, um ponteiro é grande o suficiente para indexar todas as
unidades de memória presentes no sistema. Isso torna possível a um programa tentar
acessar um endereço que corresponde a uma área inválida ou desautorizada da memória,
o que é chamado de falha de segmentação. Por outro lado, alguns sistemas possuem mais
unidades de memória que endereços. Nesse caso, é utilizado um esquema mais complexo
para acessar diferentes regiões da memória, como o de segmentação ou paginação.
Para fornecer uma interface consistente, algumas arquiteturas fornecem E/S mapeada em
memória, o que permite que enquanto alguns endereços são referenciados como áreas de
memória, outros são referenciados como registradores de dispositivos do computador,
como equipamentos periféricos.

[editar] Usos
Ponteiros são diretamente suportados sem restrições em C, C++, D e Pascal, entre outras
linguagens. São utilizados para construir referências, elemento fundamental da maioria
das estruturas de dados, especialmente aquelas não alocadas em um bloco contínuo de
memória, como listas encadeadas, árvores ou grafos.
Ao lidar com arranjos, um operação crítica é o cálculo do endereço para o elemento
desejado no arranjo, o que é feito através da manipulação de ponteiros. De fato, em
algumas linguagens (como C), os conceitos de "arranjo" e "ponteiro" são intercambiáveis.
Em outras estruturas de dados, como listas encadeadas, ponteiros são usados como
referências para intercalar cada elemento da estrutura com seus vizinhos (seja anterior ou
próximo).
Ponteiros também são utilizados para simular a passagem de parâmetros por referência
em linguagens que não oferecem essa construção (como o C). Isso é útil se desejamos
que uma modificação em um valor feito pela função chamada seja visível pela função que
a chamou, ou também para que uma função possa retornar múltiplos valores.
Linguagens como C, C++ e D permitem que ponteiros possam ser utilizados para apontar
para funções, de forma que possam ser invocados como uma função qualquer. Essa
abordagem é essencial para a implementação de modelos de re-chamada (callback),
muito utilizados atualmente em bibliotecas de rotinas para manipulação de interfaces
gráficas. Tais ponteiros devem ser tipados de acordo com o tipo de retorno da função o
qual apontam. Ponteiros para função se assemelham a functores, ainda que o conceito
função objeto seja mais abrangente.

[editar] Exemplos
Abaixo é mostrado o exemplo da declaração de uma lista encadeada em C, o que não
seria possível sem o uso de ponteiros:
#define LISTA_VAZIA NULL /* a lista encadeada vazia é representada por
NULL */

struct link {
void *info; /* conteúdo do nó da lista */
struct link *prox; /* endereço do próximo nó da lista; LISTA_VAZIA
se este é o último nó */
};
Note que essa definição recursiva de ponteiros é a mesma que a definida em Haskell:
data Link a = Nil {- lista vazia -}
| Cons a (Link a) {- a cons nó de um valor de tipo a e
outro nó -}
A definição com referências, por outro lado, possui checagem de tipo, sem confusão de
símbolos. Por essa razão, estruturas de dados em C geralmente são utilizadas com o
auxílio de funções de encapsulamento, que são cuidadosamente verificadas contra erros.
A mesma definição de lista encadeada pode ser codificada em Fortran utilizando
ponteiros, como segue:
type real_list_t
real :: sample_data(100)
type (real_list_t), pointer :: next => null ()
end type

type (real_list_t), target :: my_real_list

type (real_list_t), pointer :: real_list_temp

real_list_temp => my_real_list

do
read (1,iostat=ioerr) real_list_temp%sample_data
if (ioerr /= 0) exit
allocate (real_list_temp%next)
real_list_temp => real_list_temp%next
end do
Vetores em C são somente ponteiros para áreas consecutivas da memória. Logo:
#include <stdio.h>

int main() {
int arranjo[5] = { 2, 4, 3, 1, 5 };

printf("%p\n", arranjo); /* imprime o endereço do arranjo

*/
printf("%d\n", arranjo[0]); /* imprime o primeiro elemento do
arranjo, 2 */
printf("%d\n", *arranjo); /* imprime o primeiro inteiro do
endereço apontado pelo arranjo, que é o primeiro elemento, 2 */
printf("%d\n", arranjo[3]); /* imprime o quarto elemento do
arranjo, 1 */
printf("%p\n", arranjo+3); /* imprime o terceiro endereço após o
início do arranjo */
printf("%d\n", *(arranjo+3)); /* imprime o valor no tercero
endereço após o início do arranjo, 1 */

return 0;
}
Tal operação é chamada aritmética de ponteiros, e é usada em índices de ponteiros. O
uso dessa técnica em C e C++ é discutido posteriormente neste mesmo artigo.
Ponteiros podem ser usados para passar variáveis por referência, permitindo que seus
valores modificados tenham efeito no escopo anterior do programa, como exemplificado
no código C abaixo:
#include <stdio.h>

void alter(int *n) {

*n = 120;
}

int main() {
int x = 24;
 int *endereco= &x; /* o operador '&' (leia-se "referênca") retorna
o endereço de uma variável */

printf("%d\n", x); /* mostra x */

printf("%p\n", endereco); /* mostra o endereço de x */
alter(&x); /* passa o endereço de x como referência, para alteração
*/
printf("%d\n", x); /* mostra o novo valor de x */
printf("%p %p\n", endereco, &x); /* note que o endereço de x não
foi alterado */

return 0;
}
Ponteiros podem ser usados para apontar para funções, permitindo, por exemplo, a
passagem de funções como parâmetro de outras funções. O código em C abaixo
demonstra tal funcionalidade:
#include <stdio.h>

int soma = 0; /* armazena a soma */

int produto = 1; /* armazena o produto */

void fsoma(int valor)

{
soma += valor;
}

void fproduto(int valor)

{
produto *= valor;
}

void mapeamento_funcao_lista(lista *L, void (*funcaoptr)(int))

{
lista_no *no;
no = L->inicio;
while (no != NULL)
{
funcaoptr(no->valor); /* invoca o ponteiro de função */
no = no->proximo;
}
}

int main()
{
lista *L;

/* ... preenche a lista com valores ... */

mapeamento_funcao_lista(L, fsoma); /* calcula o somatório dos

elementos da lista */
mapeamento_funcao_lista(L, fproduto); /* calcula o produtório dos
elementos da lista */

printf("Somatorio: %d\nProdutorio %d\n", soma, produto); /* imprime

na tela os resultados */
 return 0; /* retorno bem sucedido */
}
Note que, no exemplo acima, a rotina para a execução de código para cada elemento da
lista (técnica conhecida como mapeamento) é implementada somente uma vez. O
mapeamento é novamente exemplificado abaixo em uma rotina para determinar se
elementos em uma lista são pares ou ímpares, codificado em ML:
fun map(F, nil) = nil
| map(F, x::xs) = F(x)::map(F, xs);

map(fn x => x mod 2, [1,2,3,4,5,6,7,8,9]);

A função map() recebe como entrada um valor e uma lista. Neste caso, o valor passado é
uma função (x mod 2, uma implementação utilizando cálculo lambda para retornar se
dado valor é par). Tal função é mapeada recursivamente, sendo executada em cada
elemento da lista.

[editar] Situações de uso

Os ponteiros são necessários para a alocação dinâmica de memória, para seqüências de
dados alocados e para a passagem ou o retorno através referência. Neste último é
importante citar a relevância no desempenho, pois é muito mais rápido alocar um
ponteiro para um objeto de memória já existente do que alocar o objeto inteiro
novamente. Além do mais, alocando o objeto novamente não podemos alterar o original.

[editar] Ponteiros tipados e conversão

Em várias linguagens, ponteiros possuem a restrição adicional de apontar para objetos de
um tipo específico de dado. Por exemplo, um ponteiro pode ser declarado para apontar
para um inteiro. A linguagem tentará prevenir o programador de apontar para objetos que
não são inteiros, ou derivados de ponteiros, como números de ponto flutuante,
eliminando alguns tipos básicos de erro cometidos por programadores.
Apesar disso, poucas linguagens definem tipagem restrita de ponteiros, pois
programadores freqüentemente se encontram em situações nas quais desejam tratar um
objeto de um tipo como se tivesse outro. Nesses casos, é possível converter o tipo de um
ponteiro. Algumas conversões são sempre seguras, enquanto outras são perigosas,
possivelmente resultando em comportamento incorreto do sistema. Apesar de geralmente
ser impossível determinar em tempo de compilação se tais conversões são seguras,
algumas linguagens armazenam informações sobre tipagem em tempo de execução
(como o processo RTTI do C++), que podem ser usadas para confirmar se tais conversões
perigosas são válidas, em tempo de execução. Outras linguagens simplesmente aceitam
uma aproximação conservadora de conversões seguras, ou apenas não aceitam
conversões.

[editar] Perigos na utilização de ponteiros

Como ponteiros permitem ao programa acessar objetos que não são explicitamente
declarados previamente, permitem uma variedade de erros de programação. Apesar disso,
o poder fornecido por eles é tão grande que existem tarefas computacionais que são
difíceis de ser implementadas sem sua utilização. Para ajudar nesse aspecto, várias
linguagens criaram objetos que possuem algumas das funcionalidades úteis de ponteiros,
ainda que evitando alguns tipos de erro.
Um grande problema com ponteiros é que enquanto são manipulados como números,
podem apontar para endereços não utilizados, ou para dados que estão sendo usados para
outros propósitos. Várias linguagens, incluindo a maioria das linguagens funcionais e
linguagens recentes, como C++ e Java, trocaram ponteiros por um tipo mais ameno de
referência. Tipicamente chamada de "referência", pode ser usada somente para
referenciar objetos sem ser manipulada como número, prevenindo os tipos de erros
citados anteriormente. Índices de vetores são lidados como um caso especial. As
primeiras versões de Fortran e Basic omitiam completamente o conceito de ponteiros.

[editar] Ponteiro selvagem

CRON
OMET
RO
DIGIT
AL

Come
ntário
s
[1]
Come
ntário
enviad
o por
doradu
em
18/02/
2010 -
14:19h
:

gostei
[2]
Come
ntário
enviad
o por
allen.k
onstan
z em
19/02/
2010 -
18:03h
:

Faz
um pra
calcula
r regra
de três
compo
sta
també
m!
:D

Este
fonte
trata
de
maneir
a bem
simple
sa
pesqui
sa
sequen
cial
em
uma
matriz.

[ Dow
nload:
PESQ
UISA.
C][
Enviar
nova
versão
]

[ Esco
nder
código
-
fonte ]
/*
Progra
ma
PESQ
UISA.
C */

#inclu
de
<stdio.
h>
#inclu
de
<string
.h>

int
main(v
oid)
{
int
i,acha;
char
NOM
E[10]
[40],
PESQ[
40],
resp;

puts("\
nPesq
uisa
sequen
cial de
nomes
\n\n");

/*
Entrad
a de
dados
*/
for (i =
0; i <=
9; i++)
{
printf(
"Digit
eo
%2do.
nome:
",i +
1);
fflush(
stdin);
fgets(
NOM
E[i],40
,stdin);

/*
Proces
sament
o da
pesqui
sa
enqua
nto
resp =
s */
resp =
's';
while
(resp
== 's' ||
resp
== 'S')
{
puts("\
nEntre
com o
nome
a ser
pesqui
sado:
");
fflush(
stdin);
fgets(P
ESQ,4
0,stdin
);

i = 0;
acha =
0; //
false
while
(i <= 9
&&
acha
== 0)
if
(strcm
p(PES
Q,NO
ME[i])
== 0)
acha =
1;
else
i++;

if
(acha
== 1)
printf(
"%s
foi
localiz
ado na
posica
o
%d",P
ESQ,i
+ 1);
else
printf(
"%s
nao foi
localiz
ado",P
ESQ);

printf(
"\n\nC
ontinu
a?
[S]IM
/
[N]AO
+
<Enter
>: ");
fflush(
stdin);
resp =
getcha
r();
}
return(
0);
}