Docsity
Docsity

Prepare-se para as provas
Prepare-se para as provas

Estude fácil! Tem muito documento disponível na Docsity


Ganhe pontos para baixar
Ganhe pontos para baixar

Ganhe pontos ajudando outros esrudantes ou compre um plano Premium


Guias e Dicas
Guias e Dicas


apostila de C, Notas de estudo de Física

programando em c

Tipologia: Notas de estudo

Antes de 2010

Compartilhado em 30/11/2009

Gaucho_82
Gaucho_82 🇧🇷

4.6

(52)

211 documentos

1 / 165

Toggle sidebar

Esta página não é visível na pré-visualização

Não perca as partes importantes!

bg1
PONTIFICÍA UNIVERSIDADE CATÓLICA DO PARANÁ – PUCPR
PROGRAMA DE PÓS-GRADUAÇÃO EM INFORMÁTICA APLICADA – PPGIA
CENTRO DE CIÊNCIAS EXATAS E DE TECNOLOGIA
MESTRADO EM INFORMÁTICA APLICADA
Programação em C
Um curso básico e abrangente
por
David Menoti
CURITIBA – OUTUBRO - 2002
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b
pf1c
pf1d
pf1e
pf1f
pf20
pf21
pf22
pf23
pf24
pf25
pf26
pf27
pf28
pf29
pf2a
pf2b
pf2c
pf2d
pf2e
pf2f
pf30
pf31
pf32
pf33
pf34
pf35
pf36
pf37
pf38
pf39
pf3a
pf3b
pf3c
pf3d
pf3e
pf3f
pf40
pf41
pf42
pf43
pf44
pf45
pf46
pf47
pf48
pf49
pf4a
pf4b
pf4c
pf4d
pf4e
pf4f
pf50
pf51
pf52
pf53
pf54
pf55
pf56
pf57
pf58
pf59
pf5a
pf5b
pf5c
pf5d
pf5e
pf5f
pf60
pf61
pf62
pf63
pf64

Pré-visualização parcial do texto

Baixe apostila de C e outras Notas de estudo em PDF para Física, somente na Docsity!

PONTIFICÍA UNIVERSIDADE CATÓLICA DO PARANÁ – PUCPR

PROGRAMA DE PÓS-GRADUAÇÃO EM INFORMÁTICA APLICADA – PPGIA

CENTRO DE CIÊNCIAS EXATAS E DE TECNOLOGIA

MESTRADO EM INFORMÁTICA APLICADA

Programação em C

Um curso básico e abrangente

por David Menoti

CURITIBA – OUTUBRO - 2002

ii

  • 1 INTRODUÇÃO Sumário
    • 1.1 Um pouco de História
  • 2 PRIMEIROS PASSOS.....................................................................................................
    • 2.1 A linguagem C é sensível a escrita ( Case Sensitive )................................................
    • 2.2 Estrutura de um programa em C
    • 2.3 Dois primeiros programas
      • 2.3.1 Primeiro programa............................................................................................
      • 2.3.2 Segundo programa............................................................................................
    • 2.4 Introdução às Funções..............................................................................................
      • 2.4.1 Argumentos
      • 2.4.2 Retornando valores...........................................................................................
      • 2.4.3 Forma geral
    • 2.5 Introdução Básica às Entradas e Saídas
      • 2.5.1 Caracteres
      • 2.5.2 Strings
      • 2.5.3 printf
      • 2.5.4 scanf
    • 2.6 Introdução a Alguns Comandos de Controle de Fluxo
      • 2.6.1 if
      • 2.6.2 for
    • 2.7 Comentários
    • 2.8 Palavras Reservadas do C
    • 2.9 Avaliação..................................................................................................................
  • 3 VARIÁVEIS, CONSTANTES, OPERADORES E EXPRESSÕES
    • 3.1 Nomes de Variáveis
    • 3.2 Os Tipos do C...........................................................................................................
    • 3.3 Declaração e Inicialização de Variáveis...................................................................
    • 3.4 Constantes
      • 3.4.1 Constantes dos tipos básicos
      • 3.4.2 Constantes hexadecimais e octais
      • 3.4.3 Constantes strings.............................................................................................
      • 3.4.4 Constantes de barra invertida iii
    • 3.5 Operadores Aritméticos e de Atribuição
    • 3.6 Operadores Relacionais e Lógicos
      • 3.6.1 Operadores Relacionais....................................................................................
      • 3.6.2 Operadores Lógicos..........................................................................................
      • 3.6.3 Operadores Lógicos Bit a Bit
    • 3.7 Expressões................................................................................................................
      • 3.7.1 Conversão de tipos em expressões
      • 3.7.2 Expressões que Podem ser Abreviadas
      • 3.7.3 Encadeando expressões: o operador , (vírgula)................................................
      • 3.7.4 Tabela de Precedências do C............................................................................
    • 3.8 Modeladores ( Casts )
    • 3.9 Avaliação..................................................................................................................
  • 4 ESTRUTURAS DE CONTROLE DE FLUXO...............................................................
    • 4.1 O Comando if
      • 4.1.1 O else................................................................................................................
      • 4.1.2 O if-else-if
      • 4.1.3 A expressão condicional...................................................................................
      • 4.1.4 ifs aninhados.....................................................................................................
      • 4.1.5 O Operador?
    • 4.2 O Comando switch
    • 4.3 O Comando for.........................................................................................................
      • 4.3.1 O loop infinito
      • 4.3.2 O loop sem conteúdo........................................................................................
    • 4.4 O Comando while.....................................................................................................
    • 4.5 O Comando do-while
    • 4.6 O Comando break.....................................................................................................
    • 4.7 O Comando continue................................................................................................
      • 4.7.1 O Comando goto
    • 4.8 Avaliação..................................................................................................................
  • 5 MATRIZES E STRINGS.................................................................................................
    • 5.1 Vetores
    • 5.2 Strings.......................................................................................................................
      • 5.2.1 gets
      • 5.2.2 strcpy iv
      • 5.2.3 strcat
      • 5.2.4 strlen
      • 5.2.5 strcmp
    • 5.3 Matrizes....................................................................................................................
      • 5.3.1 Matrizes bidimensionais...................................................................................
      • 5.3.2 Matrizes de strings
      • 5.3.3 Matrizes multidimensionais
      • 5.3.4 Inicialização
      • 5.3.5 Inicialização sem especificação de tamanho
  • 6 PONTEIROS
    • 6.1 Como Funcionam os Ponteiros
    • 6.2 Declarando e Utilizando Ponteiros...........................................................................
    • 6.3 Ponteiros e Vetores...................................................................................................
      • 6.3.1 Vetores como ponteiros....................................................................................
      • 6.3.2 Ponteiros como vetores
      • 6.3.3 Strings...............................................................................................................
      • 6.3.4 Endereços de elementos de vetores
      • 6.3.5 Vetores de ponteiros.........................................................................................
    • 6.4 Inicializando Ponteiros.............................................................................................
    • 6.5 Ponteiros para Ponteiros...........................................................................................
    • 6.6 Cuidados a Serem Tomados ao se Usar Ponteiros
    • 6.7 Avaliação..................................................................................................................
  • 7 FUNÇÕES........................................................................................................................
    • 7.1 A Função
    • 7.2 O Comando return....................................................................................................
    • 7.3 Protótipos de Funções
    • 7.4 O Tipo void
    • 7.5 Arquivos-Cabeçalhos
    • 7.6 Escopo de Variáveis
      • 7.6.1 Variáveis locais
      • 7.6.2 Parâmetros formais...........................................................................................
      • 7.6.3 Variáveis globais
    • 7.7 Passagem de parâmetros por valor e passagem por referência
    • 7.8 Vetores como Argumentos de Funções.................................................................... v
    • 7.9 Os Argumentos argc e argv....................................................................................
    • 7.10 Recursividade
    • 7.11 Outras Questões......................................................................................................
    • 7.12 Avaliação................................................................................................................
  • 8 DIRETIVAS DE COMPILAÇÃO
    • 8.1 As Diretivas de Compilação...................................................................................
    • 8.2 A Diretiva include
    • 8.3 As Diretivas define e undef....................................................................................
      • 8.3.1 A diretiva define.............................................................................................
      • 8.3.2 A diretiva undef..............................................................................................
    • 8.4 As Diretivas ifdef e endif
    • 8.5 A Diretiva ifndef
    • 8.6 A Diretiva if
    • 8.7 A Diretiva else........................................................................................................
    • 8.8 A Diretiva elif.........................................................................................................
  • 9 ENTRADAS E SAÍDAS PADRONIZADAS................................................................
    • 9.1 Introdução...............................................................................................................
    • 9.2 Lendo e Escrevendo Caracteres
      • 9.2.1 getche e getch
      • 9.2.2 putchar............................................................................................................
    • 9.3 Lendo e Escrevendo Strings...................................................................................
      • 9.3.1 gets
      • 9.3.2 puts
    • 9.4 Entrada e Saída Formatada.....................................................................................
      • 9.4.1 printf
      • 9.4.2 scanf
      • 9.4.3 sprintf e sscanf................................................................................................
    • 9.5 Abrindo e Fechando um Arquivo...........................................................................
      • 9.5.1 fopen...............................................................................................................
      • 9.5.2 exit..................................................................................................................
      • 9.5.3 fclose
    • 9.6 Lendo e Escrevendo Caracteres em Arquivos........................................................
      • 9.6.1 putc
      • 9.6.2 getc vi
      • 9.6.3 feof
    • 9.7 Outros Comandos de Acesso a Arquivos...............................................................
      • 9.7.1 Arquivos pré-definidos...................................................................................
      • 9.7.2 fgets
      • 9.7.3 fputs................................................................................................................
      • 9.7.4 ferror e perror
      • 9.7.5 fread................................................................................................................
      • 9.7.6 fwrite
      • 9.7.7 fseek
      • 9.7.8 rewind.............................................................................................................
      • 9.7.9 remove............................................................................................................
    • 9.8 Fluxos Padrão.........................................................................................................
      • 9.8.1 fprintf..............................................................................................................
      • 9.8.2 fscanf
    • 9.9 Avaliação................................................................................................................
  • 10 TIPOS DE DADOS AVANÇADOS..........................................................................
    • 10.1 Modificadores de Acesso
      • 10.1.1 const
      • 10.1.2 volatile............................................................................................................
    • 10.2 Especificadores de Classe de Armazenamento
      • 10.2.1 auto
      • 10.2.2 extern..............................................................................................................
      • 10.2.3 static
      • 10.2.4 register............................................................................................................
    • 10.3 Conversão de Tipos................................................................................................
    • 10.4 Modificadores de Funções
      • 10.4.1 pascal
      • 10.4.2 cdecl
      • 10.4.3 interrupt
    • 10.5 Ponteiros para Funções...........................................................................................
    • 10.6 Alocação Dinâmica
      • 10.6.1 malloc
      • 10.6.2 calloc
      • 10.6.3 realloc vii
      • 10.6.4 free..................................................................................................................
    • 10.7 Alocação Dinâmica de Vetores e Matrizes
      • 10.7.1 Alocação Dinâmica de Vetores
      • 10.7.2 Alocação Dinâmica de Matrizes
  • 11 TIPOS DE DADOS DEFINIDOS PELO USUÁRIO................................................
    • 11.1 Estruturas - Primeira parte......................................................................................
      • 11.1.1 Criando
      • 11.1.2 Usando............................................................................................................
      • 11.1.3 Matrizes de estruturas.....................................................................................
    • 11.2 Estruturas - Segunda parte......................................................................................
      • 11.2.1 Atribuindo
      • 11.2.2 Passando para funções....................................................................................
      • 11.2.3 Ponteiros.........................................................................................................
    • 11.3 Declaração Union...................................................................................................
    • 11.4 Enumerações
    • 11.5 O Comando sizeof..................................................................................................
    • 11.6 O Comando typedef
    • 11.7 Uma aplicação de structs: as listas simplesmente encadeadas
  • 12 Considerações finais...................................................................................................
  • Referências
  • Gabarito das Avaliações.........................................................................................................

Programação em C, David Menoti, PPGIA – PUCPR, 2003

1 INTRODUÇÃO

Este curso tem como objetivo apresentar os conceitos básicos da linguagem de programação C. A linguagem de programação C possui tanto características de “baixo nível” quanto “alto nível”, sendo esta uma de suas maiores vantagens.

A linguagem Assembler , uma linguagem “imortal”, é recomendada para aplicações que exigem recursos de baixo nível e excelente desempenho. Enquanto que linguagens como Delphi e Visual Basic são indicadas para aplicações de alto nível, onde são necessários recursos que facilitem a geração de interface com o usuário. O que acontece, hoje, é que estão sendo construídas linguagens cada vez mais específicas para cada tipo de aplicação. Entretanto, a linguagem C é recomendada para o desenvolvimento de aplicações onde existe um balanço entre estes dois extremos, baixo nível e alto nível. Com isto a linguagem C está cada vez mais restrita, apesar de ter se tornado muito popular, a aplicações científicas ou a aplicações onde não existam linguagens específicas que facilitem a vida do programador.

O C é uma linguagem de programação genérica que é utilizada para a criação de programas diversos como processadores de texto, planilhas eletrônicas, sistemas operacionais, programas de comunicação, programas para a automação industrial, gerenciadores de bancos de dados, programas de projeto assistido por computador, programas para a solução de problemas da Engenharia, Física, Química e outras Ciências, etc ... É bem provável que o software que você usou para imprimir este texto tenha sido escrito em C ou C++.

Na atualidade, a maioria dos recursos de programação oferecidos, juntamente com o sistema operacional e o próprio compilador C, são implementados em C. Ressaltando-se que existem várias versões de compiladores C para os mais diversos sistemas operacionais.

Neste curso estudar-se-á a estrutura do ANSI C, o C padronizado pela ANSI ( American National Standards Institute ), aceito pela maioria dos compiladores. Serão apresentadas ainda algumas funções comuns em compiladores para alguns sistemas operacionais. Quando não houver equivalentes para as funções em outros sistemas, apresentar-se-á formas alternativas de uso dos comandos.

A linguagem C pertence a família de linguagem que tem como características a confiabilidade, a modularidade, recursos de baixo nível, a simplicidade, facilidade de uso e portabilidade.

Programação em C, David Menoti, PPGIA – PUCPR, 2003

2 PRIMEIROS PASSOS

2.1 A linguagem C é sensível a escrita ( Case Sensitive )

Uma importante característica da linguagem C é que ela é sensível a escrita (do inglês Case Sensitive ), ou seja, letras maiúsculas e minúsculas fazem diferença. Quando se declara uma variável com o nome Contador , ela será diferente de contador , CONTADOR , CoNtAdOr e todas as demais variações possíveis da palavra contador que difiram de Contador. Da mesma maneira, os comandos do C for e while , por exemplo, só podem ser escritos em minúsculas pois caso contrário o compilador não irá interpretá-los como sendo comandos, mas sim como variáveis.

2.2 Estrutura de um programa em C

Uma particularidade interessante no programa C é seu aspecto modular e funcional, em que, o próprio programa principal é uma função. Esta forma de apresentação da linguagem facilita o desenvolvimento de programas, pois permite o emprego de formas estruturadas e modulares.

<definições de pré-processamento> <protótipos de funções> <declarações de variáveis globais> void main(void) { /* corpo da função principal, com declarações de suas variáveis, seus comandos e funções */ }

func( [lista de parâmetros] ) <declaração dos parâmetros> { /* corpo da função func( ) com suas declarações de variáveis, comandos e funções */ }

Figura 2-1 Estrutura de um programa em C Primeiramente, inserimos as definições de pré-processamento. Estas definições são aqueles comandos iniciados com o símbolo #. Estas definições são processadas, antes que a compilação do código realmente comece, daí vem-se o nome de definições de pré- processamento.

Programação em C, David Menoti, PPGIA – PUCPR, 2003

Os protótipos de funções que serão utilizadas no programa devem ser declarados 1 anteriormente da utilização das mesmas. Por exemplo, se a função main “precisa” de uma função que está definida abaixo da mesma, esta função deve ser declarada antes. Caso uma função invocada por uma função primeira não seja declarada antes desta função primeira o compilador C, dirá que a tal função invocada não foi declara/definida.

As variáveis que são declaradas fora do corpo de funções são tidas como variáveis globais. Estas variáveis são “vistas” por todas as funções.

A função main é uma função que deve existir em todo programa escrito em C. Já a sintaxe apresentada neste exemplo, diz que esta função tanto receberá um parâmetro vazio^2 ( void ) quanto retornará um valor vazio.

As demais funções são definidas da forma como se apresenta na Figura 2-1. Primeiramente o tipo de retorno é declarado, depois se deve declarar o nome da função, seguido de seus parâmetros.

Cada parâmetro contido na lista de parâmetros deve ser declarado, antes da abertura de chave {. Podemos também declarar os parâmetros na própria lista de parâmetros. Isto será mais bem evidenciado quando estivermos estudando as funções em C.

Vale lembrar que a estrutura na Figura 2-1 não é fixa, apesar de ser recomendada. A estrutura pode ser alterada dependendo da experiência do programador.

2.3 Dois primeiros programas

2.3.1 Primeiro programa

O primeiro, e mais simples, programa em C apresentado neste curso é mostrado abaixo:

#include <stdio.h> /* Um Primeiro Programa */ int main () { printf ("Oi mundo!\n"); return(0); }

(^1) É importante salientar a diferença entre declaração e definição de função. Uma função primeiramente é declarada, depois ela é definida, ou seja, implementada. Nada, porém, impede que a mesma seja declara e definida juntamente. (^2) Podemos entender também vazio ( void) como sendo nada (inexistência).

Programação em C, David Menoti, PPGIA – PUCPR, 2003

2.3.2 Segundo programa

Vejamos agora um programa mais complicado:

#include <stdio.h> int main () { int Dias; /* Declaracao de Variaveis / float Anos; printf ("Entre com o número de dias: "); / Entrada de Dados / scanf ("%d",&Dias); Anos=Dias/365.25; / Conversao Dias->Anos */ printf ("\n\n%d dias equivalem a %f anos.\n",Dias,Anos); return(0); } Vamos entender como o programa acima funciona. São declaradas duas variáveis chamadas Dias e Anos. A primeira é um int (inteiro) e a segunda um float (ponto flutuante). As variáveis declaradas como ponto flutuante existem para armazenar números que possuem casas decimais, como 5,1497.

É feita então uma chamada à função printf() , que coloca uma mensagem na tela. Queremos agora ler um dado que será fornecido pelo usuário e colocá-lo na variável inteira Dias. Para tanto usamos a função scanf(). A string "%d" diz à função que iremos ler um inteiro. O segundo parâmetro passado à função diz que o dado lido deverá ser armazenado na variável Dias. É importante ressaltar a necessidade de se colocar um & antes do nome da variável a ser lida quando se usa a função scanf(). O motivo disto só ficará claro mais tarde. Observe que, no C, quando temos mais de um parâmetro para uma função, eles serão separados por vírgula.

Temos então uma expressão matemática simples que atribui a Anos o valor de Dias dividido por 365.25 (365.25 é uma constante do tipo ponto flutuante 365,25). Como Anos é uma variável float o compilador fará uma conversão automática entre os tipos das variáveis (veremos isto com detalhes mais tarde).

A segunda chamada à função printf() tem três argumentos. A string "\n\n%d dias equivalem a %f anos.\n" diz à função para pular duas linhas, colocar um inteiro na tela, colocar a mensagem " dias equivalem a " , colocar um valor float na tela, colocar a mensagem " anos." e pular outra linha. Os outros parâmetros são as variáveis, Dias e Anos , das quais devem ser lidos os valores do inteiro e do float , respectivamente.

AUTO AVALIAÇÃO

Programação em C, David Menoti, PPGIA – PUCPR, 2003

O que faz este programa?

#include <stdio.h> int main() { int x; scanf("%d",&x); printf("%d",x); return(0); }

2.4 Introdução às Funções

Uma função é um bloco de código de programa que pode ser usado diversas vezes em sua execução. O uso de funções permite que o programa fique mais legível, mais bem estruturado. Um programa em C consiste, no fundo, de várias funções colocadas juntas.

Abaixo o tipo mais simples de função:

#include <stdio.h>

int mensagem () /* Funcao simples: so imprime Ola! */ { printf ("Ola! "); return(0); }

int main () { mensagem(); printf ("Eu estou vivo!\n"); return(0); } Este programa terá o mesmo resultado que o primeiro exemplo da seção anterior (2.3.1). O que ele faz é definir uma função mensagem() que coloca uma string na tela e retorna 0. Esta função é chamada a partir de main() , que, como já vimos, também é uma função. A diferença fundamental entre main e as demais funções do problema é que main é uma função especial, cujo diferencial é o fato de ser a primeira função a ser executada em um programa.

2.4.1 Argumentos

Argumentos são as entradas que a função recebe. É através dos argumentos que passamos parâmetros para a função. Já vimos funções com argumentos. As funções printf() e scanf() são funções que recebem argumentos. Vamos ver um outro exemplo simples de função com argumentos: #include <stdio.h>

Programação em C, David Menoti, PPGIA – PUCPR, 2003

2.4.2 Retornando valores

Muitas vezes é necessário fazer com que uma função retorne um valor. As funções que vimos até aqui estavam retornando o número 0. Podemos especificar um tipo de retorno indicando-o antes do nome da função. Mas para dizer ao C o que vamos retornar precisamos da palavra reservada return. Sabendo disto fica fácil fazer uma função para multiplicar dois inteiros e que retorna o resultado da multiplicação. Veja: #include <stdio.h> int prod (int x,int y) { return (x*y); }

int main () { int saida; saida=prod (12,7); printf ("A saida e: %d\n",saida); return(0); } Veja que, como prod retorna o valor de 12 multiplicado por 7, este valor pode ser usado em uma expressão qualquer. No programa fizemos a atribuição deste resultado à variável saida, que posteriormente foi impressa usando o printf. Uma observação adicional: se não especificarmos o tipo de retorno de uma função, o compilador C automaticamente suporá que este tipo é inteiro. Porém, não é uma boa prática não se especificar o valor de retorno e, neste curso, este valor será sempre especificado.

Com relação à função main, o retorno sempre será inteiro. Normalmente faremos a função main retornar um zero quando ela é executada sem qualquer tipo de erro.

Mais um exemplo de função, que agora recebe dois floats e também retorna um float:

#include <stdio.h> float prod (float x,float y) { return (x*y); }

int main () { float saida; saida=prod (45.2,0.0067); printf ("A saida e: %f\n",saida); return(0); }

Programação em C, David Menoti, PPGIA – PUCPR, 2003

2.4.3 Forma geral

Apresentamos aqui a forma geral de uma função: tipo_de_retorno nome_da_função (lista_de_argumentos) { código_da_função }

AUTO AVALIAÇÃO

Veja como você está. Escreva uma função que receba e some (a função deve somente fazer o cálculo) dois inteiros e retorne o valor da soma.

2.5 Introdução Básica às Entradas e Saídas

2.5.1 Caracteres

Os caracteres são um tipo de dado: o char. O C trata os caracteres ('a', 'b', 'x', etc ...) como sendo variáveis de um byte (8 bits). Um bit é a menor unidade de armazenamento de informações em um computador. Os inteiros ( int s) têm um número maior de bytes. Dependendo da implementação do compilador, eles podem ter 2 bytes (16 bits) ou 4 bytes ( bits). Isto será melhor explicado nos capítulos posteriores. Na linguagem C, também podemos usar um char para armazenar valores numéricos inteiros, além de usá-lo para armazenar caracteres de texto. Para indicar um caractere de texto usamos apóstrofes. Veja um exemplo de programa que usa caracteres: #include <stdio.h> int main () { char Ch; Ch='D'; printf ("%c",Ch); return(0); } No programa acima, %c indica que printf() deve colocar um caractere na tela. Como vimos anteriormente, um char também é usado para armazenar um número inteiro. Este número é conhecido como o código ASCII correspondente ao caractere. Veja o programa abaixo:

#include <stdio.h> int main () { char Ch; Ch='D'; printf ("%d",Ch); /* Imprime o caracter como inteiro */

Programação em C, David Menoti, PPGIA – PUCPR, 2003

um caractere com valor inteiro igual a zero (código ASCII igual a 0). O terminador nulo também pode ser escrito usando a convenção de barra invertida do C como sendo '\0'. Embora o assunto vetores seja discutido posteriormente (5.2), veremos aqui os fundamentos necessários para que possamos utilizar as strings. Para declarar uma string, podemos usar o seguinte formato geral: char nome_da_string[tamanho]; Isto declara um vetor de caracteres (uma string) com número de posições igual a tamanho. Note que, como temos que reservar um caractere para ser o terminador nulo, temos que declarar o comprimento da string como sendo, no mínimo, um caractere maior que a maior string que pretendemos armazenar. Vamos supor que declaremos uma string de 7 posições e coloquemos a palavra João nela. Teremos:

J o a o \ ... ... No caso acima, as duas células não usadas têm valores indeterminados. Isto acontece porque o C não inicializa variáveis, cabendo ao programador esta tarefa. Portanto as únicas células que são inicializadas são as que contêm os caracteres 'J', 'o', 'a', 'o' e '\0'.

Se quisermos ler uma string fornecida pelo usuário podemos usar a função gets(). Um exemplo do uso desta função é apresentado abaixo. A função gets() coloca o terminador nulo na string, quando você aperta a tecla "Enter".

#include <stdio.h> int main () { char string[100]; printf ("Digite uma string: "); gets (string); printf ("\n\nVoce digitou %s",string); return(0); } Neste programa, o tamanho máximo da string que você pode entrar é uma string de 99 caracteres. Se você entrar com uma string de comprimento maior, o programa irá aceitar, mas os resultados podem ser desastrosos. Veremos porque posteriormente.

Como as strings são vetores de caracteres (5.2), para se acessar um determinado caractere de uma string, basta "indexarmos", ou seja, usarmos um índice para acessarmos o caractere desejado dentro da string. Suponha uma string chamada str. Podemos acessar a segunda letra de str da seguinte forma:

str[1] = 'a';

Programação em C, David Menoti, PPGIA – PUCPR, 2003

Por quê se está acessando a segunda letra e não a primeira? Na linguagem C, o índice começa em zero. Assim, a primeira letra da string sempre estará na posição 0. A segunda letra sempre estará na posição 1 e assim sucessivamente. Segue um exemplo que imprimirá a segunda letra da string "Joao", apresentada acima. Em seguida, ele mudará esta letra e apresentará a string no final.

#include <stdio.h> int main() { char str[10] = "Joao"; printf("\n\nString: %s", str); printf("\nSegunda letra: %c", str[1]); str[1] = 'U'; printf("\nAgora a segunda letra eh: %c", str[1]); printf("\n\nString resultante: %s", str); return(0); } Nesta string, o terminador nulo está na posição 4. Das posições 0 a 4, sabemos que temos caracteres válidos, e portanto podemos escrevê-los. Note a forma como inicializamos a string str com os caracteres 'J' 'o' 'a' 'o' e '\0' simplesmente declarando char str[10] = "Joao". Veremos, posteriormente que "Joao" (uma cadeia de caracteres entre aspas) é o que chamamos de string constante, isto é, uma cadeia de caracteres que está pré-carregada com valores que não podem ser modificados. Já a string str é uma string variável, pois podemos modificar o que nela está armazenado, como de fato fizemos.

No programa acima, %s indica que printf() deve colocar uma string na tela. Vamos agora fazer uma abordagem inicial às duas funções que já temos usado para fazer a entrada e saída.

2.5.3 printf

A função printf() tem a seguinte forma geral: printf (string_de_controle,lista_de_argumentos); Teremos, na string de controle, uma descrição de tudo que a função vai colocar na tela. A string de controle mostra não apenas os caracteres que devem ser colocados na tela, mas também quais as variáveis e suas respectivas posições. Isto é feito usando-se os códigos de controle, que usam a notação %. Na string de controle indicamos quais, de qual tipo e em que posições estão as variáveis a serem apresentadas. É muito importante que, para cada código de controle, tenhamos um argumento na lista de argumentos. Apresentamos agora alguns dos códigos % :