Fiscomp FA-01 2011-1

Instituto de Fsica Armando Dias Tavares Departamento de Fsica Aplicada e Termodinmica
Fsica Computacional A
DFAT/
FiscompFA
ltima atualizao: maro 2011
Primeiros Programas: constantes e variveis tipo caractere

Professor: Anibal Leonardo Pereira
Estagirios: 2004/1 a 2005/2 Luciana Conceio Iecker Lima 2010/1 Magali dos Santos Leodato 2009/1 a 2010/2 Filipe da Fonseca Cordovil Monitores: 2001/1 2002/2 2003/1 a 2003/2 2003/1 a 2003/2 2003/1 a 2005/2 2004/1 a 2005/2 2006/1 a 2007/2 2006/1 a 2007/2 2008/1 a 2008/2 2008/1 a 2009/2 2011/1 a
Diego Chagas Garcia Erick Azevedo Meirelles Luciana Maria dos Santos Azevedo Tatiana Gonalves Martins Renato Nascente Jnior Pblio Martins Romano M. Carreiro Luiz Fernando Rosalba Telles Souza Paulo Henrique Pfitzner Filipe da Fonseca Cordovil Magali dos Santos Leodato Filipe da Fonseca Cordovil
1. Introduo
Existem inmeras linguagem de programao disponveis para uso, entre as quais podemos citar: Fortran, C, Pascal, C++, Java, etc.. Cada linguagem de programao foi criada e desenvolvida para tornar fcil a implementao de um certo tipo de tarefa. Cada linguagem de programao possui qualidades e fraquezas. Dentre as vrias linguagens de programao existentes, Fortran importante para quem trabalha na rea cientfica, porque muitas atividades necessrias cincia envolvem o uso de clculo numrico. Alm disto, a linguagem de programao Fortran fcil de ser aprendida, muito eficiente para a realizao de clculos numricos, orientada a objetos e (uma das razes mais importante) pode ser utilizada na computao em paralelo. Por estes motivos, o Fortran uma linguagem muito importante, principalmente, para os fsicos e engenheiros.
A linguagem de programao C, prpria para controlar tarefas ligadas ao sistema operacional dos computadores, tambm pode ser utilizada para a realizao de clculos numricos, mas apresenta um grau de dificuldade maior de aprendizagem do que o Fortran. A linguagem de programao C++, que uma linguagem orientada a objeto, tambm pode ser utilizada, mas tambm apresenta grande dificuldade de aprendizado. A ttulo de curiosidade, mas tambm porque permite evidenciar uma atitude bastante equivocada (no muito difcil de ser encontrada), apresenta-se um texto tirado do livro Classical Fortran Programming for engineering and scientific applications de Michael Kupferschimd de 2002: Colleges often invite faculty from other schools to evaluate the local curriculum. One such reviewer had almost finished his visit to a computer science department, and was about to give the dean of the school a favorable report, when someone carelessly mentioned having taught a course in numerical methods using Fortran. Incredulous, the visitor arched an eyebrow and looked down his nose with sudden contempt. "FORTRAN," he sneered, "is the language of peasants!" I was not present to enjoy this incident, so I can only assume the report I heard was accurate, but even if apocryphal it makes a good story and several important points about Fortran programming. Hence the attitude of this book, and part of my motivation for writing it.
DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

Traduo livre: Faculdades frequentemente convidam professores e administradores de outras escolas para avaliar o currculo local. Um destes visitantes terminando sua visita no departamento de cincia computacional, estava quase a ponto de emitir seu parecer favorvel ao responsvel pela escola, quando algum descuidadamente mencionou que havia ministrado uma disciplina de mtodo numrico utilizando Fortran. Incrdulo, o visitante arqueou um sobrancelha e olhando com ar superior, subitamente deixa escapar FORTRAN. Ento com ar de desdm pronuncia a lngua dos ignorantes. Eu no estava presente para apreciar este incidente, ento somente posso assumir que o relato que ouvi correto, mas mesmo sendo questionvel ele d uma boa estria e destaca vrios pontos importantes sobre o Fortran. Esta atitude motivou a escrita deste livro.
Resumidamente, pode-se dizer que as principais razes para o uso da linguagem de programao Fortran so:
alta performance: poucas linguagem de programao tm performance comparvel ao Fortran nos clculos numricos linguagem moderna: permite trabalhar de forma bastante adequada as complexidades apresentadas forte nos problemas numricos: mas, tambm possibilita implementar tarefas no numricas muito utilizada no campo cientfico: especialmente pelos fsicos e engenheiros ( em 1996: 32% dos usurios de estaes de trabalho envolvidos com engenharia e cincia usavam o Fortran) dispe de muitas bibliotecas (grtis e comerciais) de alta qualidade contendo inmeras funes e subrotinas disponveis para uso fcil de aprender e usar: mais fcil do que a linguagem C ou a linguagem C++ linguagem orientada a objeto permite escrever programas sob o paradigma de Orientao a Objeto computao em paralelo: permite escrever programas para serem usados na computao em paralelo. Computao em paralelo cada vez mais necessrio para a programao de alta performance
2. Primeiro Programa em Fortran

A linguagem de programao utilizada em nossa disciplina o Fortran: Fortran 2003. IMPORTANTE No momento, o compilador gfortran, utilizado na disciplina, no considerado um compilador Fortran 2003, mas sim um compilador Fortran 95 com extenses gnu (extenses disponibilizadas pela gnu). Isto se deve ao fato de padro Fortran 95 estar completamente implementado no compilador gfortran enquanto existem algumas especificaes do padro Fortran 2003 ainda no implementadas. ENTRETANTO, as caractersticas do padro Fortran 2003 ainda no implementadas no compilador gfortran no impedem que ele seja utilizado como um compilador Fortran 2003 para a maioria dos programas escritos em Fortran 2003 (a menos, claro, que se utilize explicitamente alguma caracterstica ainda ausente). Porque nossa disciplina no far uso de nenhuma das caractersticas do Fortran 2003 que ainda esto ausentes no compilador gfortran e porque a implementao delas est sendo feito e dever estar completa num futuro prximo, optamos por fazer uso do Fortran 2003 e no do Fortran 95. Tudo isto, significa que o gfortran se comporta como um compilador Fortran 2003, a menos que se necessite de alguma caracterstica ainda no implementada no compilador. Como elas (para ns) so de uso pouco frequente, o compilador NA PRTICA se comporta como um compilador Fortran 2003. Um detalhe a mais: na realidade o gfortran um compilador gnu. O que isto significa? Significa que ele um compilador

3
ou ou
Fortran 95 completo com extenso gnu disponveis (as extenses do gnu) Fortran 2003 ainda no finalizado com extenses gnu Fortran 2008 ainda no finalizado com extenses gnu
Ainda no implementado
Conforme dito, o compilador gfortran (que utilizamos) usualmente compila os programas usando o padro Fortran 2003 (na realidade o Fortran 2008). Ele no chamado de Fortran 2003 porque ainda restam algumas caractersticas do padro Fortran 2003 (e tambm do padro Fortran 2008) no implementadas no compilador. Do site do gnu (http://gcc.gnu.org/wiki/Fortran2003 em 08/02/2011) as seguintes caractersticas so citadas como ainda no implementadas no compilador gfortran:

Assncronos IO implementa assncronos real I/O, atualmente isto sncrono Extenso de especificadores de formato I/O especificadores i/o do tipo no default Excees IEEE (TR15580) Finalizao de sub-rotinas Opo KIND= especificando MACLOC, MINLOC e SHAPE Alguns tipos de expresses de inicializao Expresses no inicializadas no seletor de caso I/O de tipo definido pelo usurio Polimorfismo completo (incluindo polimorfismo ilimitado)
Esta folha de atividades inicia a apresentao e uso da linguagem de programao Fortran (Fortran 2003). Por este motivo ela contm conceitos bsicos do Fortran e tambm os conhecimentos necessrios execuo de um programa Fortran, em nosso ambiente de trabalho (ambiente Linux o uso do ambiente MS-Windows no muito diferente). Todas as atividades desta folha de atividades foram especialmente projetadas para facilitar o processo de aprendizado, portanto no deixe de ler cuidadosamente o material apresentado , pratique e (principalmente) procure entend-los. A maior parte dos conceitos sero abordados novamente em folhas subsequentes, mas nem todos, por isto no acumule dvidas. Leitura prvia: muito conveniente que se faa uma leitura prvia desta folha como um todo antes de iniciar o
trabalho. Leia completamente a folha de atividade sem se preocupar em decorar ou entender todos os detalhes apresentados, durante a leitura prvia. A inteno de fazer uma leitura prvia a de obter uma viso global do assunto, o que ajudar bastante quando for iniciar o trabalho O pargrafo que segue, que modifiquei fazendo a troca de duas palavras scripting programming e scripts programs escrito por Mendel Cooper, representam bem a filosofia adotada em nossa folha de atividades. No poderia escrever, sucintamente, algo to bom quanto ele o fez: The exercises and heavily-commented examples invite active reader participation, under the premise that the only way to really learn programming is to write programs. Paragrafo modificado do livro: Advanced Bash-Scripting Guide An in-depth exploration of the art of shell scripting Mendel Cooper Traduo Livre: Os exerccios e exemplos detalhadamente comentados convida participao do leitor ativo sob a premissa de que a nica forma de realmente aprender programao escrevendo programas.
Programas exemplos No deixe de escrever e executar todos os programas exemplos. Esta e as outras folhas de atividades contm vrios exemplos. Voc tem que escrev-los e execut-los para vlos funcionando. Ao fazer isto, voc estar estudando e treinado o uso da linguagem de programao Fortran.
pode copiar e colar (o famoso ctrl-c e ctrl-v) mas no deixe de lado a tarefa de estudar os conceitos e a lgica utilizada nos programas das atividades
Atividades sob sua responsabilidade Algumas atividades estaro sob sua inteira responsabilidade, claro, elas no podem deixar de ser feitas. Elas so importantes. 11 02 04 00 atividades atividades atividades atividades exemplos exemplos com ajustes e/ou acrscimos para serem feitas para serem ajustadas e/ou acrescidas
Esta Folha contm 17 Atividades
Seu professor de laboratrio (e/ou teoria) poder alterar esta relao !
Atividade 01
Nossa primeira atividade consiste em escrever o cdigo fonte de um programa Fortran, compilar e executar o programa.
Entregar em meio magntico: 1. programa: mensagem_01 mensagem_01.f03
Exemplo:
Este ser nosso primeiro programa em Fortran, por isto ele bastante simples. Usando o editor de texto, escreva o programa. Depois usando um terminal, compile-o. A seguir execute-o. No deixe de ler as informaes disponibilizadas pois elas serviro de apoio para a implementao de todos os passos necessrios realizao da atividade
O processo para escrever, compilar e executar um programa envolve os seguintes passos:

Criar um diretrio de trabalho Escrever o programa fonte em Fortran salvar o programa no diretrio de trabalho Abrir um terminal fazer o diretrio de trabalho ser o diretrio onde o programa foi salvo Compilar o programa Executar o programa
O passo-a-passo que segue ajudar na implementao da tarefa.

1. Criando o diretrio de trabalho Para manter o trabalho organizado voc tem que criar um diretrio de trabalho ( uma pasta) na sua conta. Pode ser na sua rea de trabalho (desktop) ou ento onde voc julgar mais conveniente, mas no deve ser no seu pendrive, pois trabalhar no HD do computador mais rpido e seguro. O nome do diretrio que est sendo criado segue a regra indicada na sequncia: turma nome folha-atividades (sem espaos entre eles)
O nome do diretrio criado ser similar a: 03filipe01
03filipe01
Turma: 03 Aluno: filipe Folha de Atividades: 01
(use somente letras minsculas)
Claro que voc usar sua turma, seu nome e o nmero da folha de atividades que est sendo feita.
A home page da disciplina contm o link Datas-e-Atividades onde disponibilizada uma tabela com os cdigos utilizados para identificar as folhas de atividades. Consulte este link para obter o cdigo referente folha de atividades em uso.
Para criar o diretrio de trabalho, abra o navegador de arquivo:
No painel da esquerda, clique em rea de trabalho. Isto abrir a rea de trabalho (desktop) no painel direito. Coloque o ponteiro do mouse dentro do painel direito e clique no boto direito do mouse. Escolha a opo criar Criar pasta.
Escreva o nome do diretrio (por exemplo: 03anibal01).
2. Escrevendo o programa Fortran Para escrever o programa abra o editor de texto gedit.
Aps o editor gedit estar disponvel para uso, escreva o cdigo fonte do programa mensagem_01 (texto mostrado a seguir):
program mensagem_01 !-------------------------------------------------------------------! Propsito: Escrever uma mensagem na tela do micro !-------------------------------------------------------------------! Arquivo:mensagem_01.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------print* print*," ==========================" print*," Programa mensagem_01 " print*," ==========================" print* print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: " print* print*,"---------------------------------------------------------------------------" print* print*," (*) Linha de comentrio " print* print*," o programa contm 7 linhas de comentrios: " print*," elas so as linhas que iniciam com o caractere exclamao: ! " print* print*," (*) Constante Literal do tipo caractere " print* print*," tambm chamado de string " print*," so os textos envolvidos por aspas: "" " print* print*," (*) instruo PRINT" print* print*,"o cdigo fonte do programa contm 23 instrues print " print* end program mensagem_01
3. Salvando o arquivo No editor gedit: depois de escrever o texto, clique em: Salvar como
Depois que a janela referente a Salvar como abrir, navegue pelos diretrio at entra no diretrio que criou (exemplo: 03anibal01). Escreva o nome do arquivo que ser salvo na caixa chamada nome:
Nesta primeira atividade o nome do arquivo : mensagem_01.f03 (assim mesmo como est escrito, tudo em letras minsculas). Depois clique no boto salvar. Pronto ! Voc salvou o programa da atividade 1 no diretrio que criou, com o nome mensagem_01.f03 4. Abrindo o Terminal Abra o terminal para poder realizar a compilao do programa.
Depois que a janela do terminal aparece necessrio ( na maioria das vezes necessrio) mudar o diretrio de trabalho para o diretrio que contm o programa ( neste caso o arquivo mensagem_01.f03) Os seguintes conhecimentos so relevantes:
comando pwd no prompt do terminal execute o comando pwd
no terminal, escreva pwd seguido de um espao em branco e pressione a tecla <enter>
(pwd significa print working directory) este comando mostra no terminal o diretrio de trabalho
se no estiver no diretrio certo se o diretrio de trabalho no for o diretrio que contm o arquivo mensagem_01.f03, no terminal, escreva o comando cd <diretrio> para mudar o diretrio de trabalho para l exemplo: supondo que o programa est no diretrio 03anibal01 voc deve digitar o seguinte:
cd 03anibal01
ou ento digitar o comando que fornece o caminho completo para se chegar at o diretrio desejado:
cd "/home/anibal/rea de trabalho/03anibal01"
listando o contedo do diretrio de trabalho no prompt do terminal, digite o comando ls -l
(-l menos letra ele, no menos um)
escreva ls seguido de um espao em branco seguido de -l para ento pressionar a tecla <enter>
isto mostrar o contedo do diretrio de trabalho, num formato longo (se preferir use o comando ls) se estiver no diretrio correto, voc ver na lista que mostra o contedo do diretrio o nome do arquivo mensagem_01.f03
5. Compilando o programa
Depois de ter escrito e salvo o programa fonte, aberto o terminal e colocado o diretrio de trabalho no diretrio onde o programa se encontra voc pode compilar o programa. O processo de compilao cria um programa em linguagem de mquina que o computador pode executar (rodar). Para isto, no prompt do terminal digite o comando:
gfortran -o mensagem_01 mensagem_01.f03
e pressione a tecla <enter>
Ateno: escreva o comando exatamente como mostrado:

Se tudo correu bem, o terminal simplesmente retorna ao aviso de comando ( prompt) sem emitir nenhuma mensagem. Caso exista(m) erro(s) nos cdigos fontes do mdulo, uma mensagem ser emitida. Se isto ocorreu, v para o editor de texto e corrija o(s) erro(s), salve o arquivo e repita o processo de compilao. Depois da compilao do programa contido no arquivo mensagem_01.f03 voc ter o programa executvel (arquivo mensagem_01) que estar no diretrio de trabalho. Verifique isto executando o comando ls -l no terminal ou ento usando o navegador de arquivo. 6. Execuo do programa A execuo do programa mensagem_01 feita assim:
./mensagem_01
isto , no prompt do terminal, digite um ponto seguido de uma barra seguido do nome do arquivo e depois pressione a tecla <enter>. Observe: o nome do programa mensagem_01 e do arquivo que contem o programa executvel mensagem_01 enquanto o nome do arquivo que contm o programa fonte mensagem_01.f03 A execuo do programa ir mostrar na tela do micro a seguinte sada: Sada no terminal do computador
anibal@anibaldsk:/home/anibal/03anibal01/$ ./mensagem_01 ========================== Programa mensagem_01 ========================== O programa escreve, na tela do micro, o conjunto de mensagens abaixo: --------------------------------------------------------------------------(*) Linha de comentrio o programa contm 7 linhas de comentrios: elas so as linhas que iniciam com o caractere exclamao: ! (*) Constante Literal do tipo caractere tambm chamado de string so os textos envolvidos por aspas: " (*) instruo PRINT o cdigo fonte do programa contm 23 instrues print anibal@anibaldsk:/home/anibal/03anibal01/$
10
3. O processo de compilao
O texto a seguir fornece informaes ligada ao processo de compilao. Em nosso laboratrio o comando gfortran roda o compilador gfortran. O compilador gfortran desenvolvido pela Fundao Software Livre ( FSF = Free Software Foundation), usualmente conhecida como Projeto Gnu, um compilador Fortran (Fortran 95 completo e Fortran 2003 com algumas caractersticas do padro Fortran 2003 ainda em implementao em 10-03-2011) que pode ser instalado e utilizado tanto no Linux quanto no MS-Windows. O compilador gfortran pode ser obtido no endereo: http://gcc.gnu.org/wiki/GFortran
Depois de ter escrito e salvo o programa num arquivo, a criao do programa executvel se faz pelo processo de compilao. Programa executvel o programa que o computador utiliza para rodar (executar) as tarefas especificadas no cdigo fonte do programa (tambm se usa a expresso inglesa run). Atualmente a maioria dos compiladores adota a estratgia de utilizar somente um comando para realizar a compilao e o carregamento ( link-edio) do programa fonte. As duas tarefas ( que so diferentes) so realizadas sequencialmente, dando a impresso de serem uma s. Na realidade a compilao a execuo somente da etapa um do processo mostra na figura que segue.
Etapas na compilao Se na etapa um (compilao) no for encontrado erro, o compilador passa imediatamente para a etapa dois (carregamento ou link-edio) e gera o programa executvel. Caso exista um erro no cdigo fonte ( ou mais de um erro) o processo no passa ao carregamento ( link-edio) e uma ou mais mensagens de erros so escritas na tela do microcomputador indicando ( ou tentando indicar) o tipo de erro e onde ele ocorreu. Algumas vezes a referncia do erro ( ou erros) que o compilador faz no ajuda muito, porque ela indica que h um erro numa declarao que no est errada. O que realmente aconteceu que o compilador no conseguiu identificar precisamente a causa do erro (a sua origem) e portanto no pode ajudar. Neste caso, voc deve procurar o erro nas instrues anteriores da instruo indicada pela mensagem de erro do compilador, desconsiderar o tipo do erro indicado porque a indicao do erro no est correta. Um erro existe, mas a sua indicao, pelo compilador, no feita de forma correta. Apesar disto e erro tem que ser identificado e eliminado. Este processo, as vezes, difcil mesmo. A melhor soluo para lidar com indicaes de erros no muito clara ( ou enganosa) adotar o conceito de programao estruturada. Dividir e subdividir o programa que se est escrevendo em unidades menores que permitiro mais facilmente identificar o erro.
11
O que fazer quando o compilador encontra erro(s)

Se existe um erro no programa (ou mais de um), o compilador indica isto. Leia a mensagem emitida pelo compilador. Ela identifica a origem (unidade de programa), o tipo de erro, linha e coluna em que o erro aconteceu. D ateno especial ao primeiro erro encontrado pelo compilador. Retorne ao programa fonte e localize o primeiro erro para sua correo. No se preocupe com os erros subsequentes ( segundo em diante). Elimine o primeiro erro. Aps ter feito a correo do primeiro erro salve o programa fonte e execute novamente a compilao Caso ainda existam erros, a compilao ser novamente interrompida e nova(s) mensagen(s) de erro(s) ser(o) mostrada(s). O que fazer? Retorne ao programa fonte para a correo do primeiro erro ( novo primeiro erro). Salve o programa fonte corrigido e depois compile novamente o programa. Repita estes procedimentos tantas vezes quanto necessrios, at que o programa compile sem erros criando o programa executvel.
A compilao do programa
O compilador Fortran utilizado em nosso laboratrio trabalha no modo texto, isto , no tem interface grfica, por isto ele necessita ser executado num terminal.
Editor gedit e um terminal

Se trabalhou com o editor gedit, abra um terminal e no prompt do terminal entre com o comando:
Reforando o entendimento do processo de compilao

No comando gfortran -o mensagem_01 mensagem_01.f03 o "gfortran" refere-se ao compilador Fortran depois do gfortran foi escrita a chave "-o". A opo "-o mensagem_01" usado para que o programa executvel receba o nome mensagem_01. Se esta opo no for usada o programa criar um executvel de nome a.out (no Linux) ou ento a.exe (no MS-Windows). O sinal menos ( - ) indica uma opo; a letra " o" indica que a sada (output) e o nome que segue a letra " o" especifica o nome que ser dado ao programa executvel que est sendo criado. Em nosso caso ser criado um
12
programa executvel com o nome mensagem_01. O "mensagem_01.f03" especifica o nome do arquivo que contm os cdigos fonte ( programa) em Fortran que ser lido pelo compilador. Observe a diferena: nome do arquivo que contm os cdigos fontes (o programa escrito) em Fortran que ser lido pelo compilador. O nome do arquivo que contm o programa escrito em Fortran, no o nome do programa Se o programa fonte no contiver erro(s) o comando gfortran -o mensagem_01 mensagem_01.f03 criar o programa executvel mensagem_01 no diretrio atual.
Executando o programa
No prompt do terminal digite o nome do arquivo e pressionar a tecla <enter>
./mensagem_01 <enter>
No Linux, o ponto barra ("./" ) utilizado para indicar o diretrio atual. Ento ./mensagem_01 significa:
execute o programa executvel mensagem_01 que est no diretrio em que me encontro no momento
3.1. Para treinar

Para ver na prtica como o compilador se comporta quanto existem erros, deliberadamente, introduza um erro conhecido no programa e veja o que ocorre no processo de compilao. Usando o programa mensagem_01: Remova a letra "p" de uma instruo print. Salve o arquivo. Compile o programa e veja o que acontece. Recomponha o programa.
Remova o asterisco ( *) do instruo print em vez de remover a letra " p ". Salve o arquivo. Compile o programa e veja o que acontece. Recomponha o programa.
Remova uma das aspas ("). Salve o arquivo. Compile o programa e veja o que acontece. Recomponha o programa.
Troque o nome do programa somente na instruo end program. Salve o arquivo. Compile o programa e veja o que acontece. Recomponha o programa. Alm destas trocas, escolha outro tipo de alterao e veja o comportamento do compilador.
13
4. Programa Fortran
Um programa (programa em Fortran) pode ser construdo utilizando-se quatro tipos de unidades de programa (program-units). As unidades de programa existentes no Fortran so:

unidade programa principal unidade programa mdulo unidade subprograma externo unidade programa dados em bloco
(main-program unit) (module unit) (external-subprogram unit) (block-data program unit)
Um programa Fortran consiste de um programa principal e qualquer nmero ( inclusive zero) dos outros tipo de unidades de programa. possvel utilizar qualquer combinao, desde que exista somente um programa principal. A figura ao lado, mostra o caso geral entretanto, a melhor forma de se pensar um programa Fortran que ele composto por um programa principal e tantos mdulos quanto se queira ou necessite ( inclusive nenhum mdulo).
A figura que segue evidencia as melhores formas de se pensar um programa em Fortran.
Programa Principal (caso mais simples)
Programa Principal e um Mdulo (caso comum)
Programa Principal e vrios Mdulos (muito til)
Melhores formas de se pensar um programa Fortran
Unidade de programa dados em bloco
A unidade de programa dados em bloco (block data program unit) pode ser utilizada para prover valores iniciais para objetos de dados em blocos comuns nomeados ( named common blocks). Esta unidade de programa foi muito utilizada nos padres anteriores (at o padro FORTRAN 77). O padro atual dispe de formas mais adequada para realizar esta tarefa, portanto, no utilize unidade de programa dados em bloco. Este tipo de unidade de programa est no padro para manter compatibilidade com as verses anteriores.
14
Subprograma externo
As principais caractersticas de um subprograma externo, no Fortran 2003, so:
subprograma externo escrito em Fortran

at o padro FORTRAN 77, subprograma externo era a nica forma que o programador podia utilizar para escrever uma funo e uma sub-rotina ( coletivamente identificadas pelo termo procedimento). A partir do Fortran 90, o padro criou maneiras mais eficiente para se dispor de procedimentos. Atualmente, um subprograma externo escrito em Fortran completamente desnecessrio. Esta forma de criar procedimentos externos ainda existe no Fortran para manter compatibilidade com as verses anteriores, portanto no utilize subprogramas externos escritos em Fortran
subprograma externo escrito em outra lngua de programao

subprograma funo externa e subprograma sub-rotina externa podem ser utilizadas para acessar cdigos de programao escrito em outra lngua de programao ( por exemplo, na linguagem de programao C). Isto permite que outra lngua de programao possa ser utilizada junto com um programa Fortran. Esta a forma recomendada de uso para os subprogramas externos no Fortran. Entretanto, pouco provvel que um usurio comum (em nosso caso, ns) necessite fazer uso deste recurso, porm ele est disponvel.
5. Programa Principal
Nossa primeiro atividade realizou uma tarefa bastante simples, por causa disto o programa Fortran escrito utilizou apenas uma unidade de programa: o programa principal. O programa Fortran mensagem_01 (arquivo: mensagem_01.f03) um programa principal Fortran, ou como usualmente chamamos, um programa.
Veja a diferena: programa programa aquilo que ir fazer a tarefa global desejada. Por estar escrito na linguagem de programao Fortran, o mais adequado seria cham-lo de programa Fortran, mas acaba-se chamando apenas de programa programa mensagem_01 o programa principal recebeu o nome mensagem_01, por isto ele o programa mensagem_01 programa executvel mensagem_01 a compilao do programa com a chave -o possibilita escolher um nome para o arquivo que conter o programa executvel que ser criado. Ns usamos -o mensagem_01 portanto o arquivo chama-se mensagem_01 Observe que o programa executvel mensagem_01 est guardado no arquivo mensagem_01 arquivo mensagem_01.f03 o arquivo que contm o cdigo fonte do programa mensagem_01 chama-se mensagem_01.f03 enquanto o arquivo que contm os cdigos em linguagem de mquina (programa executvel) chama-se mensagem_01 Observe que temos : programa programa mensagem_01 programa mensagem_01 (ou programa executvel mensagem_01 ou programa executvel ou programa executvel mensagem_01) arquivo mensagem_01 arquivo mensagem_01.f03 No h obrigatoriedade do nome do programa ser igual ao nome do arquivo que contm os cdigos fontes do programa.
15
Recordando: o programa Fortran mensagem_01, foi criado utilizando-se apenas uma unidade de programa: o programa principal. O cdigo fonte do programa mensagem_01 reapresentado a seguir:
program mensagem_01 !-------------------------------------------------------------------! Propsito: Escrever uma mensagem na tela do micro !-------------------------------------------------------------------! Arquivo:mensagem_01.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------print* print*," ==========================" print*," Programa mensagem_01 " print*," ==========================" print* print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: " print* print*,"---------------------------------------------------------------------------" print* print*," (*) Linha de comentrio " print* print*," o programa contm 7 linhas de comentrios: " print*," elas so as linhas que iniciam com o caractere exclamao: ! " print* print*," (*) Constante Literal do tipo caractere " print* print*," tambm chamado de string " print*," so os textos envolvidos por aspas: "" " print* print*," (*) instruo PRINT" print* print*,"o cdigo fonte do programa contm 23 instrues print " print* end program mensagem_01
As seguintes caractersticas devem ser observadas:
instruo PROGRAM e instruo END PROGRAM No Fortran, um programa principal identificado por estas instrues. O programa principal utiliza a instruo program como primeira instruo (abertura) e a instruo end program como ltima instruo (fechamento). Os cdigos do programa (programa principal) so escritos entre estas duas instrues.
program mensagem_01 . . . . . . . . . . . . . . . . . . end program mensagem_01
escreve-se o nome do programa tanto na instruo de abertura program quanto na instruo de fechamento end program.
comentrio depois da instruo de abertura ( program mensagem_01 ) as prximas 7 linhas so comentrios. Comentrios so identificadas pelo caractere exclamao ( ! ) .
program mensagem_01 !-------------------------------------------------------------------! Propsito: Escreve mensagens na tela do micro !-------------------------------------------------------------------! Arquivo:mensagem_01.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !--------------------------------------------------------------------
16
comentrios so inseridos no programa para fornecer informao para quem est lendo os cdigos fontes (um humano). O cabealho serve para explicar o propsito do programa e disponibilizar outras informaes. O cabealho (e os comentrios dentro do programa) deve ser visto como parte integrante do programa. essencial que se tenha o hbito de escrever comentrios nos cdigos fontes dos programas.
instruo PRINT a instruo print* mostra (escreve, imprime) na tela do micro uma mensagem. Tudo aquilo que estiver escrito entre aspas na instruo print ser escrito (impresso) na tela do computador
program mensagem_01 !-------------------------------------------------------------------! Propsito: Escreve mensagens na tela do micro !-------------------------------------------------------------------! Arquivo:mensagem_01.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------print* print*," ==========================" print*," Programa mensagem_01 " print*," ==========================" print* print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: " print* print*,"---------------------------------------------------------------------------" print* print*," (*) Linha de comentrio " print* print*," o programa contm 7 linhas de comentrios: " print*," elas so as linhas que iniciam com o caractere exclamao: ! " print* print*," (*) Constante Literal do tipo caractere " print* print*," tambm chamado de string " print*," so os textos envolvidos por aspas: "" " print* print*," (*) instruo PRINT" print* print*,"o cdigo fonte do programa contm 23 instrues print " print* Nestas instrues os textos (sem as aspas) sero escritas na tela do computador (uma depois da outra)
quando as instrues print forem executadas. A instruo print possibilita escrever informaes na tela do computador para o usurio do programa. Esta caracterstica muito importante e ser utilizada na construo da documentao em tempo de execuo Observe que o texto que ser escrito pela instruo PRINT deve aparacer entre aspas ( " ) ou entre apstrofo ( ' ). No importa qual, o importante que o smbolo utilizado na abertura tem que ser o mesmo utilizado no fechamento. Por exemplo, as duas instrues que seguem so similares
print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: print*,'O programa escreve, na tela do micro, o conjunto de mensagens abaixo: " '
Alm disto, observe tambm, o uso de duas aspas seguidas ( "" ) para que apenas uma aspas aparea na mensagem escrita na tela do micro.
print*," so os textos envolvidos por aspas: "" "
Caso se utilize apenas uma aspas, o compilador ir interpretar que a aspas est terminando a mensagem (o que no est) e indicar uma mensagem de erro. Ao utilizar duas aspas juntas, o compilador interpreta que elas na realidade so uma aspas nica e escreve a aspas na tela do micro, o que realmente desejado.
17
Uma forma de se evitar o uso de duas as apas seguidas seria utilizar o apstrofo como mostrado na instruo que segue:
print*,' so os textos envolvidos por aspas: "" '
isto funciona, porque a constante literal caractere est marcada ( delimitada) pelo apstrofo e portanto as aspas no ir sinalizar para o compilador o trmino ( fechamento) da constante literal caractere.
instrues PRINT sem constante literal caractere as instrues print* que no contm nenhum texto entre aspas (ou entre apstrofos) imprime uma linha em branco na tela do computador. instruo END PROGRAM a instruo end program marca o termino do programa principal. a instruo end program mensagem_01 marca o termino do programa principal mensagem_01
program mensagem_01 !-------------------------------------------------------------------! Propsito: Escreve mensagens na tela do micro !-------------------------------------------------------------------! Arquivo:mensagem_01.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------print* print*," ==========================" print*," Programa mensagem_01 " print*," ==========================" print* print*,"O programa escreve, na tela do micro, o conjunto de mensagens abaixo: " print* print*,"---------------------------------------------------------------------------" print* print*," (*) Linha de comentrio " print* print*," o programa contm 7 linhas de comentrios: " print*," elas so as linhas que iniciam com o caractere exclamao: ! " print* print*," (*) Constante Literal do tipo caractere " print* print*," tambm chamado de string " print*," so os textos envolvidos por aspas: "" " print* print*," (*) instruo PRINT" print* print*,"o cdigo fonte do programa contm 23 instrues print " print* end program mensagem_01
6. Conjunto de Caracteres do Fortran 2003

O conjunto de caracteres que o Fortran 2003 utiliza dependente do processador, mas a estrutura do conjunto tem que ser a seguinte: 1. caracteres de controle 2. caracteres grficos letras dgitos sublinha caracteres especiais outros caracteres
18
character set).
As letras, dgitos, sublinha e os caracteres especiais formam o conjunto de caracteres do Fortran (Fortran LETRAS as 52 letras so:
ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz
as letras minsculas so equivalentes as letras maisculas, exceto no contexto caractere.

String a palavra string significa: corda, fio, cordo, conjunto de objetos, corrente entretanto muito utilizada como: cadeia de caracteres - sequncia de caracteres Contexto caractere contexto caractere so os caracteres que esto sendo empregados (usados) dentro de constante literal caractere ou dentro de um string que define um descritor de edio
DIGITOS os 10 dgitos so:
0123456789
SUBLINHA underscore, em ingls ( _ ) o caractere sublinha utilizado como caractere significativo em um nome CARACTERES ESPECIAIS os 32 caracteres especiais (no Fortran 2003) so: Caractere Nome do caractere branco = + * / \ ( ) [ ] { } , . : igual mais menos asterisco barra Barra invertida abre parnteses fecha parnteses abre colchetes fecha colchetes abre chaves fecha chaves vrgula ponto decimal ou ponto final dois pontos Caractere Nome do caractere ; ! " % & ~ < > ? ' ` ^ | $ # @ ponto e vrgula ponto de exclamao aspas porcento e-comercial til menor que Maior que ponto de interrogao apstrofo acento grave acento circunflexo barra vertical smbolo de moeda smbolo nmerico at comercial (ampersand)
19
OUTROS CARACTERES caracteres adicionais que o processador pode representar, s podem aparecer em: comentrios constantes caractere registros de entrada/sada string usado nos descritores de edio Na prtica, pode-se considerar que os caracteres e smbolos que o Fortran 2003 utiliza so os contidos na tabela ASCII.
TABELA ASCII baseada na tabela existente em: http://www.hobbyprojects.com/ascii-table/ascii-table.html (em 27/07/2010)
7. Nomes
Nomes so utilizados por vrias entidades tais como variveis, unidades de programa, argumento mudos, constantes com nome e tipos derivados. No Fortran 2003, um nome s pode conter letras, nmeros e o caractere sublinha. Alm disto, (obrigatoriamente) deve iniciar com uma letra e ter no mximo 63 caracteres.
20
Exemplos:
velocidade massa15 massa_do_corpo nome_muito_longo_que_nao_esta_errado
(tem 37 caracteres)
Atividade 02
Entregar em meio magntico: 1. programa: ano_bissexto_01 ano_bissexto_01.f03
Exemplo:
Nesta atividade, o programa escrito ir escrever na tela do micro a seguinte mensagem. --------------------------------------------------------------------------------A regra para saber se um ano ou no bissexto : (*) Todo ano divisvel por 4 um ano bissexto (*) exceo : quando o ano tambm for divisvel por 100 no um ano bissexto entretanto: todo ano divisvel por 400 sempre um ano bissexto --------------------------------------------------------------------------------Os seguintes anos so bissextos : 1600 1700 2000 1800 2400 1900
Os seguintes anos no so bissextos:
Escreva o programa ano_bissexto_01, salvando-o no arquivo ano_bissexto_01.f03. Compile e execute o programa. No esquea, o processo para escrever, compilar e executar o programa envolve os seguintes passos:

Escrever o programa fonte Compilar o programa Executar o programa
Voc pode copiar e colar os cdigos fontes para que no tenha que escrever os cdigos disponibilizados, mas isto no evita o trabalho de ajuste da diagramao dos cdigos fontes segundo o estilo de programao adotado na disciplina
Momentaneamente, voc deve fazer com que os cdigos que est escrevendo (copiando) fiquem visualmente parecidos com os cdigos fontes disponibilizados. Para voc se sentir um pouco mais confortvel, considere que, no estilo de programao que adotamos, todo programa tem: nome cabealho
No deixe de atualizar o cabealho do programa de forma adequada, ou seja, no deixe de acrescentar seu nome como revisor e a data em que isto aconteceu. ________________________________________________________________________________________ arquivo: ano_bissexto_01.f03
program ano_bissexto_01 ! !-----------------------------------------------------------------------------! Propsito: Escreve na tela do micro identificao de anos Bissextos !-----------------------------------------------------------------------------! Arquivo: ano_bissexto_01.f03

! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-----------------------------------------------------------------------------print* print*,"---------------------------------------------------------------------------------" print*,"A regra para saber se um ano ou no bissexto :" print*, print*," (*) Todo ano divisvel por 4 um ano bissexto " print*," (*) exceo : quando o ano tambm for divisvel por 100 no um ano bissexto" print*," entretanto, todo ano divisvel por 400 sempre um ano bissexto" print*,"---------------------------------------------------------------------------------" print* print*,'Os seguintes anos so bissextos : 1600 2000 2400 ' print* print*,'Os seguintes anos no so bissextos: 1700 1800 1900 ' print* end program ano_bissexto_01
21
As caractersticas importantes a serem destacadas so:
caractere sublinha o nome do programa ano_bissexto_01 espao em branco no pode aparecer dentro de nomes, por isto o uso do caractere sublinha ( underline) unindo o nome ano com os nomes bissexto e 01 espao em branco utilizado como separador, portanto se for escrito ano bissexto 01 no lugar de ano_bissexto_01 o compilador vai entender que o nome do programa apenas ano e vai interpretar bissexto como sendo o incio de uma nova instruo, o que gera uma condio de erro Recorde que um nome, no Fortran 2003, pode conter at 63 caracteres. Portanto voc pode usar nomes compostos unidos com o caractere sublinha sem problema, desde que use, no mximo, 63 caracteres
PRINT a instruo print* escreve uma linha em branco na tela do computador A instruo
print*,"-------------------------------------------------------------------------"
escreve uma linha de traos (que est colocada entre as aspas) na tela do computador. Tudo o que estiver colocado entre aspas considerado uma constante literal caractere ou constante caractere ( usual utilizar-se o termo string) e o compilador trata a constante caractere como um string e imprime o string exatamente como ele foi escrito pelo programador as aspas nas constantes literais caracteres ( strings) no fazem parte da constante, esto ali apenas para marcar o incio e o fim da constante (da mesma forma os apstrofos se eles forem usados no lugar das aspas)
comentrio uma linha completamente em branco considerada uma linha de comentrio Tudo o que for escrito depois de uma caractere de exclamao ( ! ) considerado um comentrio, portanto as linhas que seguem so comentrios
! !-----------------------------------------------------------------------------! Propsito: Escreve na tela do micro identificao de anos Bissextos !-----------------------------------------------------------------------------! Arquivo: ano_bissexto_01.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !------------------------------------------------------------------------------
22
Atividade 03
Entregar em meio magntico: 1. programa: quadro_01 quadro_01.f03
Exemplo:
Esta atividade utiliza constantes literais caractere (strings) para criar um quadro e escreve uma mensagem na tela do micro. Observe que a arrumao, a distribuio da mensagem na tela do micro e a decorao do quadro, feita dentro do string, isto , toda a distribuio das letras e smbolos utilizados so arrumados com espaos em branco dentro do string, que tem que ser diagramado pelo programador (quem escreve os cdigos fontes). O compilador no modifica o string. Ele simplesmente escreve o string na tela do micro, sem nenhum tipo de interferncia ou modificao na disposio que o programador utilizou no string Portanto, qualquer arrumao (disposio dos smbolos) deve ser feita pelo programador dentro do string que est utilizando
Escreva o programa quadro_01, salvando-o no arquivo quadro_01.f03. Compile e execute o programa. No deixe de atualizar o cabealho do programa de forma adequada, ou seja, no deixe de acrescentar seu nome como revisor e a data em que isto aconteceu. ________________________________________________________________________________________ arquivo: quadro_01.f03
program quadro_01 ! !-----------------------------------------------------------------------------! Propsito: Escreve na tela do micro um quadro com mensagem !-----------------------------------------------------------------------------! Arquivo: quadro_01.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-----------------------------------------------------------------------------print* print*,"(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)" print*,"(*) (*)" print*,"(*) Primeiro quadro (*)" print*,"(*) (*)" print*,"(*) Observe a decorao da moldura do quadro (*)" print*,"(*) (*)" print*,"(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)(*)" print* end program quadro_01
As caractersticas importante:

a aparncia (arrumao) feita pelo programador, escrevendo o string (dentro do string) o compilador no modifica ou altera o string especificado pelo programador espao em branco usado para dispor de forma conveniente os smbolos utilizados nos strings
23
Atividade 04
Exemplo:
Decorao de mensagem na tela do micro
________________________________________________________________________________________ arquivo: quadro_02.f03

program quadro_02 ! !-----------------------------------------------------------------------------! Propsito: Escreve na tela do micro um quadro com mensagem !-----------------------------------------------------------------------------! Arquivo: quadro_02.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-----------------------------------------------------------------------------print* print*,"(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)" print*,"(:) (:)" print*,"(:) Segundo quadro (:)" print*,"(:) (:)" print*,"(:) Observe a decorao da moldura do quadro (:)" print*,"(:) (:)" print*,"(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)(:)" print* end program quadro_02
Atividade 05
Exemplo:
________________________________________________________________________________________ arquivo: quadro_03.f03

program quadro_03 ! !-----------------------------------------------------------------------------! Propsito: Escreve na tela do micro um quadro com mensagem !-----------------------------------------------------------------------------! Arquivo: quadro_03.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-----------------------------------------------------------------------------print* print*,"x*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*x" print*,"x*x x*x" print*,"x*x Terceiro quadro x*x" print*,"x*x x*x" print*,"x*x Observe a decorao da moldura do quadro x*x" print*,"x*x x*x" print*,"x*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*xx*x"
24
print*
end program quadro_03
Atividade 06
Exemplo:
________________________________________________________________________________________ arquivo: quadro_04.f03

program quadro_04 ! !-----------------------------------------------------------------------------! Propsito: Escreve na tela do micro um quadro com mensagem !-----------------------------------------------------------------------------! Arquivo: quadro_04.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-----------------------------------------------------------------------------print* print*,"\>\>\>\>\>\>\>\>\>\>>::</</</</</</</</</</</" print*,">>>>>>>>> <<<<<<<<<" print*,">->->->->->->> Q U A D R O <<-<-<-<-<-<-<" print*,">>>>>>>>> <<<<<<<<<" print*,"+>+>+>+>+>+>+>+>+>+>>::<+<+<+<+<+<+<+<+<+<+<+" print* end program quadro_04
Atividade 07
Entregar em meio magntico: 1. programa: frase_Willian frase_Willian.f03
Exemplo:
Escreve frase (pensamento - citao) de Willian Shakespeare
________________________________________________________________________________________ arquivo: frase_willian.f03

program frase_Willian ! !---------------------------------------------------------------------------------! Propsito: Escreve na tela do micro uma frase de autoria de William Shakespeare !---------------------------------------------------------------------------------! Arquivo: frase_willian.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !---------------------------------------------------------------------------------print* print*," print*," print*," print* print*," Enquanto houver um louco, um poeta e um amante haver sonho, amor e fantasia. E enquanto houver sonho, amor e fantasia, " " " "

print*," print*," print* haver esperana. -- William Shakespeare -" "
25
end program frase_Willian
Utilizar strings (constantes literal caractere) para escrever mensagem na tela do micro til, mas usualmente necessitamos mais do que isto. Portanto o passo seguinte aprender a utilizar variveis.
Constante entidade (objeto de dado) um valor que no pode ser alterado durante a execuo do programa Varivel objeto de dado (entidade) valor que pode ser alterado durante a execuo do programa
Atividade 08
Entregar em meio magntico: 1. programa: meu_nome primeiro.f03
Exemplo:
Programa que define e utiliza uma varivel do tipo caractere e utiliza constantes literais do tipo caractere (strings). O programa tambm utiliza as instrues: IMPLICIT NONE, PRINT e READ
________________________________________________________________________________________ arquivo: meu_nome.f03

program meu_nome !-------------------------------------------------------------------! Propsito: escreve um nome fornecido pelo usurio na tela do micro !-------------------------------------------------------------------! Arquivo:primeiro.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------implicit none character(len=20):: nome ! print* print*,"Escreva seu nome: (mximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apstrofo (')" read*, nome print* print*, nome print* ! end program meu_nome
1. Compilando o programa
Para isto, no prompt do terminal digite o comando:
gfortran -o primeiro primeiro.f03
e pressione a tecla <enter>
Depois da compilao do programa contido no arquivo primeiro.f03 voc ter o programa executvel (arquivo primeiro) que estar no diretrio de trabalho. 2. Execuo do programa A execuo do programa meu_nome feita assim:
./primeiro
26
Observe: o nome do programa meu_nome e do arquivo que contem o programa executvel primeiro enquanto o nome do arquivo que contm o programa fonte primeiro.f03 A execuo do programa ir mostrar na tela do micro o nome que o usurio fornecer. Admitindo que o nome fornecido pelo usurio tenha sido Paulo Csar (nome composto, contendo espao em branco tem que ser fornecido pelo usurio entre aspas ou apstrofos) a sada no terminal ser similar a mostrada dentro do quadro que segue. Sada no terminal do computador
anibal@anibaldsk:/home/anibal/01anibal03$ ./primeiro Escreva seu nome: (mximo de 20 caracteres) Nomes compostos escreva entre aspas (") ou apstrofo (') 'Paulo Csar' Paulo Csar anibal@anibaldsk:/home/anibal/01anibal03$
instruo IMPLICIT NONE

a instruo implicit none utilizada para anular a definio implcita de tipo. um bom hbito de programao utilizar esta declarao nos programas Fortran, pois seu uso permite que o compilador detecte erros que de outra forma seriam muito trabalhoso e/ou difceis de serem achados. Um detalhe importante que a instruo implicit none tem que ser escrita antes das instrues de definio de tipo no programa.
program meu_nome !-------------------------------------------------------------------! Propsito: escreve um nome fornecido pelo usurio na tela do micro !-------------------------------------------------------------------! Arquivo:primeiro.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------implicit none
porque o compilador no considera os comentrios existentes no programa, ele enxerga os cdigos mostrados acima como sendo composto somente por duas linhas, ou seja:
program meu_nome implicit none
o que mostra que IMPLICIT NONE est colocada imediatamente depois da instruo program
meu_nome
declarao de tipo caractere a instruo

character(len=20):: nome
uma instruo de declarao de tipo (tipo caractere)

program meu_nome !-------------------------------------------------------------------! Propsito: escreve um nome fornecido pelo usurio na tela do micro !-------------------------------------------------------------------! Arquivo:primeiro.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !--------------------------------------------------------------------

implicit none character(len=20):: nome
27
O programa meu_nome define e utiliza uma nica varivel do tipo caractere. Tipo de dados (ou simplesmente tipo) uma maneira que a linguagem de programao tem de saber que valores podem ser guardados na entidade e quais operaes podem ser realizadas com estes valores. Por exemplo, um dado do tipo caractere no tem a operao adio disponvel. Ento, se o valor da varivel tipo caractere nome for Anibal, o Fortran sabe que a operao adicionar o nmero 5 varivel caractere nome ( ou seja, a operao de adio: Anibal + 5 ) no permitida, porque variveis do tipo caractere no possuem a operao de adio disponvel A instruo de definio de varivel de tipo caractere estabelece que a varivel nome pode conter 20 posies, ou seja, nome pode conter no mximo 20 caracteres Definio de tipo feita assim: onde:
tipo tipo,atributos::lista-variveis
pode ser :
character, integer, real, complex
ou logical
define um ou mais de um atributos do tipo que est sendo definido. Para o tipo caractere o atributo comprimento (comprimento em ingls: lenght len) sempre utilizado e especifica o nmero de caracteres para a varivel que est sendo definida.
atributos
uma lista de variveis separadas por vrgula. Neste exemplo, nossa lista possu somente uma varivel
lista-variveis character(len=20):: nome
instruo PRINT a instruo print* mostra (escreve, imprime) na tela do micro uma mensagem. Tudo aquilo que estiver escrito entre aspas na instruo print ser escrito (impresso) na tela do computador
program meu_nome !-------------------------------------------------------------------! Propsito: escreve um nome fornecido pelo usurio na tela do micro !-------------------------------------------------------------------! Arquivo:primeiro.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------implicit none character(len=20):: nome ! print* print*,"Escreva seu nome: (mximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apstrofo (')"
Nestas instrues o texto "Escreva seu nome:
(mximo de 20 caracteres)" (sem as aspas) e "Nomes compostos escreva entre aspas("") ou apstrofo (')" sero escritas na tela do computador (uma depois da outra) quando as duas instrues print forem executadas.
A instruo print possibilita escrever informaes na tela do computador para o usurio do programa. Isto muito importante. Esta caracterstica chamada de documentao em tempo de execuo Observe que o texto que ser escrito pela instruo PRINT deve aparacer entre aspas ( " ) ou entre apstrofo ( ' ). No importa qual, o importante que o smbolo utilizado na abertura tem que ser o mesmo utilizado no fechamento.
28
Alm disto, observe tambm, o uso de duas aspas seguidas ( "" ) para que apenas uma aspas aparea na mensagem escrita na tela do micro. Caso se utilize apenas uma aspas, o compilador ir interpretar que a aspas est terminando a mensagem ( o que no est) e indicar uma mensagem de erro. Ao utilizar duas aspas juntas, o compilador interpreta que elas na realidade so uma aspas nica e escreve a aspas na tela do micro, o que realmente desejado.
instruo READ uma instruo de entrada de dados. A instruo read* l (recebe) dados fornecidos ao programa pelo teclado.
program meu_nome !-------------------------------------------------------------------! Propsito: escreve um nome fornecido pelo usurio na tela do micro !-------------------------------------------------------------------! Arquivo:primeiro.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------implicit none character(len=20):: nome ! print* print*,"Escreva seu nome: (mximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apstrofo (')" read*, nome
O que for digitada usando o teclado ser atribudo varivel nome (guardado na varivel depois de se pressionar a tecla <enter> ) porque o espao em branco utilizado para separar valores do tipo caractere (string) valores compostos (por exemplo: Antnio Carlos, Maria Jos) que possuem espao em branco devem ser envolvidos (protegidos) por aspas ( " ) ou apstrofo ( ' ). Ao escrever os valor dentro de aspas ou apstrofo ele ser considerado como sendo uma entidade nica, o que realmente desejado. Por exemplo se o valor entrado for Maria Jos (sem as aspas) o valor que a varivel nome conter ser Maria, no Maria Jos (execute o programa, entre com um nome composto sem as aspas e veja o comportamento do programa)
instrues PRINT a instruo print* que no contm nenhum texto entre aspas imprime uma linha em branco na tela do computador. por sua vez, a instruo print*, nome imprime na tela do computador o valor que est guardado na varivel caractere nome
program meu_nome !-------------------------------------------------------------------! Propsito: escreve um nome fornecido pelo usurio na tela do micro !-------------------------------------------------------------------! Arquivo:primeiro.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------implicit none character(len=20):: nome ! print* print*,"Escreva seu nome: (mximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apstrofo (')" read*, nome print* print*, nome print* !
29
instruo END PROGRAM a instruo end program marca o termino do programa principal. a instruo end program meu_nome marca o termino do programa principal meu_nome
program meu_nome !-------------------------------------------------------------------! Propsito: escreve um nome fornecido pelo usurio na tela do micro !-------------------------------------------------------------------! Arquivo:primeiro.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !-------------------------------------------------------------------implicit none character(len=20):: nome ! print* print*,"Escreva seu nome: (mximo de 20 caracteres)" print*,"Nomes compostos escreva entre aspas ("") ou apstrofo (')" read*, nome print* print*, nome print* ! end program meu_nome
Atividade 09
Entregar em meio magntico: 1. programa: ano_bissexto ano_bissexto.f03
Exemplo:
Esta atividade define e utiliza uma varivel do tipo caractere e uma varivel do tipo inteira Os seguintes anos podem ser utilizados como dado de entrada para o programa: 1600 2000 2400 (so anos bissextos) 1700 1800 1900 (no so bissextos) A regra para saber se um ano bissexto ou no : Todo ano divisvel por 4 um ano bissexto exceo: quando o ano tambm for divisvel por 100 no um ano bissexto entretanto, todo ano divisvel por 400 sempre um ano bissexto
Escreva o programa ano_bissexto, salvando-o no arquivo ano_bissexto.f03. Compile e execute o programa. No deixe de atualizar o cabealho do programa de forma adequada, ou seja, no deixe de acrescentar seu nome como revisor e a data em que isto aconteceu. ________________________________________________________________________________________ arquivo: ano_bissexto.f03
program ano_bissexto ! !-----------------------------------------------------------------------------! Propsito: Solicita que o usurio entre com dois valores inteiros (nmeros) ! e depois escreve na tela do micro duas mensagem !-----------------------------------------------------------------------------! Arquivo: ano_bissexto.f03 ! Autor: Anibal L. Pereira 05/10/2010 !Revises: Anibal L. Pereira 27/11/2010 ! !-----------------------------------------------------------------------------implicit none integer:: ano_bi, ano_usual
30
print* print*,"Entre com ano bissexto " read*, ano_bi print* print*,"Agora entre com ano no bissexto " read*, ano_usual print* print*, "o ano ", ano_bi, " bissexto" print*, "o ano ", ano_usual, " no ano bissexto" print* end program ano_bissexto
As caractersticas importantes a serem destacadas so:
caractere sublinha o nome do programa ano_bissexto espao em branco no pode aparecer dentro de nomes, por isto o uso do caractere sublinha ( underline)
variveis inteiras duas variveis do tipo inteiro foram definidas: ano_bi e ano_usual observe que os nomes das variveis esto colocados numa lista
integer:: lista-de-variveis
a lista est separada da instruo de especificao por dois dois pontos ( :: ) a separao das variveis na lista feita por vrgula: integer:: ano_bi, ano_usual
PRINT a instruo print* escreve uma linha em branco na tela do computador A instruo print*,"Entre com ano bissexto " escreve o texto entre aspas na tela do computador
comentrio uma linha completamente em branco uma linha de comentrio READ a instruo read (ler) quando escrita com um asterisco ( * ) escrito pelo usurio usando o teclado do computador
read*
faz a leitura do valor que foi
a instruo read*, ano_bi l o que o usurio entra pelo teclado e escrever o valor fornecido na varivel inteira ano_bi a instruo read*, ano_usual por sua vez, coloca o valor lido na varivel inteira ano_usual
lista utilizada no PRINT a instruo print*, "o ano ", ano_bi, " bissexto" pode ser entendida assim:
print*, lista-de-sada
onde lista-de-sada uma lista composta ( neste caso) de 3 entidades separadas por vrgula, ou seja: string "o ano " varivel inteira ano_bi string " bissexto" todas separadas por vrgulas. Numa lista (usualmente) as entidades esto separadas por vrgula as aspas nas constantes literais caracteres ( strings) no fazem parte da constante, esto ali apenas para marcar o incio e o fim da constante
31
8. Programando
As informaes colocadas aqui so bastante resumidas, mas importantes, portanto leia com ateno. Aprender a programar envolve duas tarefas distintas e simultneas que podem ser colocadas sob a seguinte denominao: linguagem de programao e planejamento. 1. linguagem de programao em nosso caso a linguagem de programao Fortran 2003 2. planejamento analise e projeto Apesar de serem duas tarefas distintas (para projetos grandes, estas atividades, muito frequentemente, so realizadas no nosso caso, elas so realizadas por uma nica pessoa. Por este motivo somos levados a enfrentar algumas dificuldades. muito importante ter clareza e delimitar corretamente cada uma destas
por pessoas distintas),
tarefas para que o processo todo no se torne confuso e mais difcil do que o necessrio. Para tornar o processo de aprendizagem o mais fcil possvel, momentaneamente, nossa ateno se voltar para o item 1: linguagem de programao. Por isto iniciamos nossos trabalhos com a aproximao codifica-conserta. Posteriormente iremos fazer uso da aproximao prottipo evolutivo, muito mais produtiva
Aproximao ponha-para-funcionar
Aprender uma linguagem de programao significa aprender as regras de sintaxe e a lgica das estruturas utilizadas na linguagem estudada (nossa disciplina utiliza linguagem estruturada). Portanto, a ateno est, essencialmente, voltada para as regras de sintaxe e de utilizao das estruturas da linguagem. assim mesmo, nada h de errado com isto. Uma das formas mais rpida e direta utilizadas no processo de aprendizagem da linguagem de programao estudar o conceito e imediatamente implementar o que foi estudado escrevendo cdigos fontes. Isto o que se chama aproximao ponha-para-funcionar.
A aproximao ponha-para-funcionar bastante eficiente para evidenciar e exemplificar um conceito, uma informao, uma regra, uma implementao, ou seja, boa para aprender uma linguagem de programao, portanto serve de suporte ao item 1: item 1 linguagem de programao
Nos primrdios da computao a aproximao ponha-para-funcionar era a nica forma conhecida e por isto foi utilizada na criao de programas ( desenvolvimento de programas e de softwares ). Entretanto, a aproximao ponhapara-funcionar quando utilizada para escrever programas mostrou suas limitaes, o que fez com que outro tipo de abordagem surgisse.
A aproximao ponha-para-funcionar no serve para ser utilizada no item 2 (planejamento), porque esta aproximao acaba gerando um produto final pouco til (pela baixa qualidade do software criado) quando se pensa no desenvolvimento de um sistema
32
Aproximao codifica-conserta
A aproximao codifica-conserta (Code-Fix Approach) no mais do que uma pequena melhora na aproximao ponhapara-funcionar.
na realidade a mesma aproximao ponha-parafuncionar com a diferena de possibilitar a especificao de mais de um propsito ou requisito (aqui identificado como especificao do sistema)
Nesta aproximao, inicialmente faz-se a especificao do que se deseja ( identificao dos requisitos do sistema), depois o desenvolvedor inicia a codificao e realiza ( executa) vrios ciclos da aproximao codifica-conserta. De tempo em tempo, ele verifica se o programa escrito atende as especificaes desejadas. Quando atender, o programa est pronto. A aproximao codifica-conserta tambm tem problemas graves, tais como:
baixa qualidade do produto final, pois o produto final gerado neste processo acaba como um ajuntamento de cdigos produto final difcil de ser mantido e estendido (e muitas vezes at mesmo de ser entendido)
Observe que um produto final (software ou programa) pode ser classificado como: muito baixa complexidade baixa complexidade mdia complexidade alta complexidade. A aproximao ponha-para-funcionar pode ser utilizado com sistemas de muito baixa complexidade (essencialmente um nico propsito). A aproximao codifica-conserta pode ser utilizada para trabalho com sistemas de baixa complexidade (essencialmente uns poucos propsitos ou requisitos)
Conforme dito, neste momento, voc trabalhar utilizando a aproximao codifica-conserta. Esta aproximao utilizada porque ela permite no desviar a ateno para assuntos e conhecimentos correlatos, isto , minimiza a amplitude do assunto, procurando dirigir a ateno, essencialmente, para o assunto tratado. A aproximao codifica-conserta ser substituda pela aproximao prottipo evolutivo, que mais produtiva e por isto a forma de trabalho adotada em nosso disciplina. A aproximao prottipo evolutivo ser apresentada posteriormente.
33
Atividade 10
Entregar em meio magntico: 1. programa: numero_dias numero_dias.f03
Fazer:
Atividade com inteno de utilizar variveis do tipo caractere e do tipo inteira e entrar dados pelo teclado
Esta a primeira atividade que voc escrever sozinho.

Ela (obviamente) uma atividade simples, que utiliza os conceitos apresentados at este momento. Use os programas anteriores como modelo. DVIDA ? Na dvida, TENTE ! No fique imobilizado. Voc vai ver que o compilador no deixa voc seguir adiante se houver erro de sintaxe nos seus cdigos fontes. Erro de lgica o compilador no encontra. Eles iro aparecer quando da execuo do programa. Ser necessrio consertar todos os erros de sintaxe antes de prosseguir. No tem jeito. Para o compilador tudo errado ou tudo certo. Detalhe importante: Quando o compilador escreve vrias mensagens de erro na tela do micro, voc tem que ler a mensagem referente ao primeiro erro. No d importncia aos erros depois do primeiro, porque eles podem desaparecer depois da correo do primeiro erro. Leia a mensagem referente ao primeiro erro, v at o arquivo que contm o cdigo fonte do programa e corrija o erro. Salve o programa depois da(s) correo(es) e repita o processo de compilao do programa. Se os erros posteriores ao primeiro persistirem eles reaparecero quando for feita a nova compilao do programa. Se isto acontecer, novamente, considere apenas o primeiro erro (se houver mais de um) e repita o processo de correo do erro, para ento fazer nova compilao. assim mesmo, repete-se este processo vrias vezes at que nenhuma mensagem de erro seja emitida pelo compilador. Com a prtica, a quantidade de erros diminuem bastante e o processo todo passa a ser feito rapidamente. Voc tentou, mas no est conseguindo. Ainda tem dvida, ok, No se desespere ! ( o famoso NO PANIC ! ) . Releia todas as informaes disponibilizadas nesta atividade e se isto no for suficiente, releia o contedo apresentado nesta folha de atividades at aqui. Pergunte ao seu professor ( um colega tambm pode ajudar, pergunte! ).
Escreva o programa numero_dias e guarde-o no arquivo numero_dias.f03 O programa numero_dias deve ser escrito de forma que: defina uma varivel do tipo caractere com comprimento de 10 posies (ou 10 caracteres) chamada mes defina uma varivel do tipo inteira chamada dia solicite ao usurio do programa que entre com um valor para a varivel mes (nome completo do ms do ano) solicite ao usurio a quantidade de dias existente no ms que ele forneceu
Auxlio: (ano no bissexto tem a seguinte quantidade de dias nos meses) janeiro 31 fevereiro 28 maro 31 abril 30 maio 31 junho 30 julho 31 agosto 31 setembro 30 outubro 31 novembro 30 dezembro 31
34
A sada do programa dever ter mostrar o ms, a quantidade de dias e outras informaes que voc julgar necessrio. As atividades anteriores serviro de modelo para voc escrever esta atividade. Lembre-se de: escrever o nome do programa nas instrues de abertura e fechamento do programa principal escrever o cabealho do programa no deixe de utilizar a instruo IMPLICIT NONE use as instrues PRINT* e READ* se necessrio, use constantes literais caractere (strings): tantas quantas necessrias
compile e execute o programa
Atividade 11
Entregar em meio magntico: 1. programa: calor calor.f03
Fazer:
Nesta atividade ser utilizado apenas constantes literais caractere (strings caractere ou como usualmente falamos strings). No ser necessrio definir nenhum tipo de varivel. Tudo o que tiver que ser escrito na tela do micro estar colocado em constantes literais do tipo caractere (string). O programa, ao ser executado, dever mostrar na tela do micro o texto escrito dentro do quadro que segue: Voc sabe o que calor ? Calor energia trmica que flui de um corpo para outro em virtude da diferena de temperatura entre eles. Calor pode ser adicionado ou removido de uma substncia. Calor medido em joules no sistema internacional de medida S.I..
AUXLIO:
o texto a ser escrito (ver o quadro) pode ser considerado como sendo composto de 7 linhas: 4 linhas contendo texto e 3 linhas em branco separando as linhas com texto as linhas com texto so constantes literais caractere (strings), portanto elas sero colocada dentro de aspas recorde que as aspas (ou apstrofos, se os utilizou no lugar das aspas) no fazem parte da constante literal caractere. Eles so utilizados apenas para delimitar a constante literal caractere tudo o que voc escrever entre as aspas uma constante literal caractere (string), portanto um contexto caractere tudo o que compe o contexto caractere mostrado exatamente como ele foi escrito pelo programador. O compilador no modifica o string (a constante literal caractere). Ele mostra o string, com tudo o que foi escrito, do jeito que foi escrito linha em branco pode ser escrita com a instruo print* ou seja, com a instruo print com a lista vazia
Escreva o programa calor e salve-o no arquivo calor.f03 compile e execute o programa

REFORANDO: Constantes literais caractere (strings) tudo aquilo que est colocado entre aspas ou entre apstrofos. Um string (a forma, os caracteres utilizados e a sua disposio) mantido pelo compilador. O compilador no modifica o string
35
Atividade 12
Entregar em meio magntico: 1. programa: saudacao saudacao.f03
Fazer:
Esta atividade utiliza uma varivel caractere e vrias constantes literais caractere (vrios strings). Escreva o programa Fortran saudacao de forma que ele: solicite o nome do usurio e guarde o valor que o usurio fornece pelo teclado numa varivel caractere caracterstica a ser considerada: na definio de uma varivel caractere define-se tambm o tamanho (quantidade de caracteres) que a varivel caractere pode conter. Como no sabemos a quantidade de caracteres existente no nome do usurio que utilizar o programa, a soluo especificar um valor grande para o comprimento da varivel caractere isto evitar o corte do nome do usurio se ele for maior que o comprimento da varivel caractere que est sendo definida. Este procedimento trar inconvenientes (que voc ver na sada produzida pelo seu programa. Futuramente aprenderemos a tratar este inconveniente). No momento, para lidar com o problema do possvel corte do valor fornecido pelo usurio, defina um tamanho da varivel caractere grande o suficiente para guardar a maioria dos nomes das pessoas depois o programa escreve na tela do micro, uma saudao ao usurio. A mensagem que deve ser mostrada na tela do micro
Ol <nome> seja bem vindo. Infelizmente no vamos poder trabalha juntos. Eu s sei escrever esta mensagem na tela do micro. Tenha um bom dia. Tchau ! onde <nome> ser substitudo pelo nome fornecido pelo usurio
AUXLIO:
o programa utiliza uma varivel caractere e tantas constantes literais caractere (strings) quantas forem necessrias
Escreva o programa saudacao, salve no arquivo saudacao.f03 compile e execute o programa

1. observe que o nome do programa saudacao, isto mesmo, sem c-cedilha e sem o acento til, porque o Fortran 2003 utiliza um conjunto de caracteres (na prtica este conjunto pode ser considerado o ASCII) que no possui estes caracteres. Por isto a instruo que ser utilizada no programa ser: program saudacao
2.
por sua vez o nome do arquivo (saudacao.f03) pode ser escrito corretamente saudao.f03 porque quem trabalha com o arquivo o sistema operacional Linux e ele permite o uso de acentos e outros caracteres que o Fortran no utiliza (o Linux utiliza o conjunto de caracteres UTF-8). Mas para manter uma certa consistncia (evitar complicaes: escrever corretamente aqui, errado ali aqui assim, ali assado ...) iremos adotar uma forma nica de escrever, por isto o arquivo ser identificado por saudacao.f03 no saudao.f03
36
9. Constante Caractere
Constante caractere aparece no Fortran sob duas formas:
constante literal caractere valor do tipo caractere escrito literalmente no programa (usualmente chamada apenas de string) constante com nome caractere valor caractere constante identificado por um nome (chamada constante, mas uma constante com nome)
CONSTANTE LITERAL ou constante literal caractere. Por exemplo, os caracteres escritos entre aspas ( " ) ou entre apstrofos ( ' ) definem constantes literais tipo caractere. Ento, quando analisamos o seguimento de programa mostrado a seguir
print*,"Entre com ano bissexto " read*, ano_bi print* print*,"Agora entre com ano no bissexto " read*, ano_usual print* print*, "o ano ", ano_bi, " bissexto" print*, "o ano ", ano_usual, " no ano bissexto"
vemos que
Entre com ano bissexto Agora entre com ano no bissexto o ano bissexto o ano no ano bissexto
so seis constantes literais caractere usadas para fornecer informaes para o usurio do programa. Relembre que as aspas no fazem parte das constantes literais caractere. Observe que o valor "o ano " (sem as aspas) foi utilizada duas vezes no programa, portanto so duas constantes literais caractere diferentes, apesar delas terem exatamente os mesmo valor ( contedo).Tem-se duas constantes diferentes no uma nica repetida duas vezes. Para altera o valor de qualquer constante literal caractere ( string) necessrio alterar o valor na constante desejada (aquela que se deseja alterar). Uma constante literal caractere no tem nome. um objeto sem nome. Cada constante literal caractere nica, existe individualmente. Vrias constantes literais caractere ( mesmo que contenham o mesmo valor) so vrias constantes literais caractere diferentes, no uma nica. O seguimento de programa:
print*,"Ol print*,"Ol print*,"Ol print*,"Ol print*,"Ol Anibal" Anibal" Anibal" Anibal" Anibal"
utiliza cinco constantes literais caractere diferentes. Todas com o mesmo valor, mas so 5 constantes diferentes.
37
CONSTANTE COM NOME ou constante com nome caractere. Outro tipo de constante caractere que se pode utilizar a constante com nome caractere. A constante com nome caractere declarada utilizando-se o atributo PARAMETER. O atributo PARAMETER utilizado na declarao de tipo caractere cria uma constante com nome. A constante torna-se definida com o valor especificado na expresso de inicializao que aparece a direita do sinal de igual . A forma geral para declara uma constante com nome caractere :
character(len=*), parameter:: constante = expr-inicializao
Na declarao da constante com nome caractere o comprimento sempre feito igual a * e neste caso o comprimento da constante com nome exatamente igual ao comprimento da expr que define a constante. Ento:
character(len=*),parameter:: meu_nome = "Anibal" define a constante com nome meu_nome que tem um tamanho igual a 6 e valor igual a Anibal character(len=*),parameter:: nome_dela = "Ana" define a constante com nome nome_dela que tem um tamanho igual a 3 e valor igual a Ana
O seguimento de programa:
print*,"Ol", print*,"Ol", print*,"Ol", print*,"Ol", print*,"Ol", meu_nome meu_nome meu_nome meu_nome meu_nome
Utiliza cinco constantes literais caractere diferentes com o mesmo valor ( "Ol") e uma nica constantes com nome caractere chamada meu_nome que contm o valor "Anibal". Observe que a constante com nome foi utilizada 5 vezes, no so cinco constantes com nome diferentes. Estes cdigos fazem a mesma tarefa que o anterior, isto , mostra cinco vezes a mensagem Ol Anibal na tela do computador. Caso se queira alterar a mensagem a ser mostrada, por exemplo, para Bom dia Anibal ser necessrio altera as cinco constantes literais. Por outro lado, se o valor da constante com nome meu_nome for alterado na definio da constante com nome para, por exemplo, Paulo, as cinco mensagem mostradas na tela do computador ser alterada automaticamente. Altera-se apenas a definio da constante com nome as cinco mensagens sero automaticamente atualizadas quando o programa for executado.
character(len=*),parameter:: meu_nome="Anibal" character(len=*),parameter:: saud="Ol " character(len=*),parameter:: meu_nome="Anibal" print*,"Ol ", meu_nome print*,"Ol ", meu_nome print*,saud, meu_nome print*,"Ol ", meu_nome print*,saud, meu_nome print*,"Ol ", meu_nome print*,saud, meu_nome print*,"Ol ", meu_nome print*,saud, meu_nome print*,saud, meu_nome escreve 5 vezes a mesma mensagem Ol Anibal Ol Anibal Ol Anibal Ol Anibal Ol Anibal tem que ser escrito assim: escreve 5 vezes a mesma mensagem Ol Anibal Ol Anibal Ol Anibal Ol Anibal Ol Anibal se escrito assim:
38
character(len=*),parameter:: meu_nome="Anibal" character(len=*),parameter:: saud="Bom dia " character(len=*),parameter:: meu_nome="Paulo" print*,"Bom dia ", meu_nome print*,"Bom dia ", meu_nome print*,saud, meu_nome print*,"Bom dia ", meu_nome print*,saud, meu_nome print*,"Bom dia ", meu_nome print*,saud, meu_nome print*,"Bom dia ", meu_nome print*,saud, meu_nome print*,saud, meu_nome escreve 5 Bom dia Bom dia Bom dia Bom dia Bom dia vezes Anibal Anibal Anibal Anibal Anibal escreve 5 Bom dia Bom dia Bom dia Bom dia Bom dia vezes Paulo Paulo Paulo Paulo Paulo
Uma constante literal caractere no pode ter seu valor alterado durante a execuo do programa. No h forma disto acontecer. Para alterar o valor de uma constante literal caractere necessrio alterar o cdigo fonte do programa e depois compilar o programa alterado. Numa constante com nome caractere o valor da constante com nome tambm no pode ser alterado durante a execuo do programa. Ento qual a diferena, qual a vantagem de se utilizar constantes com nome? Constante com nome caractere:

facilita a escrita do programa torna o programa mais claro (fcil de ser lido e entendido) para trocar (se necessrio) o valor de uma constante com nome caractere, troca-se o valor na sua definio (um nico local) e o novo valor ser automaticamente usado pelo programa todo
Atividade 13
Entregar em meio magntico: 1. programa: arrumando_com_strings arrumando_com_strings.f03
Exemplo:
Escreva o programa arrumando_com_strings, salve no arquivo arrumando_com_strings.f03 compile e execute o programa O programa utiliza variveis caractere e constantes literais caractere O programa destaca como possvel alterar a apresentao na tela das variveis usando constantes literais caractere. Neste exemplo utilizou-se espaos em branco para alterar a aparncia do que mostrado na tela do micro. RELEMBRE: uma constante literal do tipo caractere (string) mantida exatamente como foi escrita, isto , preservando todos os caracteres utilizados ( inclusive os espaos) e as suas disposies
Voc pode copiar e colar os cdigos fontes, mas no deixe de ajustar a diagramao dos cdigos fontes segundo o estilo de programao adotado na disciplina
No estilo de programao que utilizamos, todo programa: tem um nome tem um cabealho utiliza a instruo implicit none destaca instrues que trabalham juntas para realizar certas tarefas
39
No deixe de atualizar o cabealho do programa de forma adequada. ________________________________________________________________________________________ arquivo: arrumando_com_strings.f03

program arrumando_com_strings ! !----------------------------------------------------------------------! Propsito: Apresenta sada na tela do micro de variveis caractere. ! A aparncia na tela do micro das variveis caractere ! modificada pelo uso de constantes literais caractere !----------------------------------------------------------------------! Arquivo: arrumando_com_strings.f03 ! Autor: Anibal L. Pereira 27/11/2010 !Revises: !----------------------------------------------------------------------implicit none character(len=5):: s1 ! s1 a s8 so 8 palavras isoladas character(len=3):: s2 ! character(len=2):: s3 !-- OBSERVAO: aqui cada varivel foi escrita numa instruo de character(len=4):: s4 !-- definio separada. Entretanto, aquelas que possuem mesmo character(len=5):: s5 !-- tamanho poderiam ter sido escritas numa mesma declarao. character(len=3):: s6 !-- Por exemplo: character(len=1):: s7 !-character(len=5):: s1, s5 character(len=10)::s8 !--------------------------------------------! entra com valores nas variveis caractere !--------------------------------------------s1 = "Entre" !-- so variveis, mas como esto definidas diretamente no s2 = "com" !-- programa elas do a impresso de serem constantes s3 = "um" s4 = "nome" s5 = "menor" s6 = "que" s7 = "9" s8 = "caracteres" !-------------------------------------------------------------------------------------! primeira impresso !------------------------------------------------------------------------------------print* print*,"=================================" print*,s1,s2,s3,s4,s5,s6,s7,s8 print*,"=================================" !------------------------------------------------------------------------------------! segunda impresso !------------------------------------------------------------------------------------print* print*,"========================================" print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6," ",s7," ",s8 print*,"========================================" !------------------------------------------------------------------------------------! terceira impresso !------------------------------------------------------------------------------------print* print*,"======================================================" print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6," ",s7," ",s8 print*,"======================================================" !------------------------------------------------------------------------------------! quarta impresso !------------------------------------------------------------------------------------print* print*,"====================================================================================== ===========" print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6," ",s7," ",s8 print*,"====================================================================================== ==========="
40
end program arrumando_com_strings
Observao sobre a questo de linha quebrada No programa arrumando_com_strings aparecem duas linhas similares a esta
print*,"=============================================================================== =================="
no Fortran uma linha fsica pode ter at 132 caracteres a linha mostrada contm 107 caracteres entretanto nosso texto, por causa do tipo de fonte e do tamanho utilizado permite escrever linhas com um mximo de 95 colunas, portanto a linha com 107 colunas aparece quebrada como se fossem duas linhas (como mostrado)
Voc deve considerar a linha como sendo uma nica ( porque a linha uma linha do Fortran e neste caso: 107 colunas podem estar dentro das 132 colunas utilizadas pelo Fortran) Este inconveniente, deve ser ser tratado por voc, porque ( por deciso nossa) a linha no ser modificada para caber em uma linha nica no texto. Se isto fosse feito o tamanho do fonte dificultaria a leitura do texto e mesmo assim ainda teramos casos em que ( como mostrado a seguir) teramos que diminuir ainda mais o tamanho do fonte. FONTE tamanho 7:
print* print*,"=================================================================================================" print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6," ",s7," ",s8 print*,"================================================================================================="
FONTE tamanho 6:
print* print*,"=================================================================================================" print*,s1," ",s2," ",s3," ",s4," ",s5," ",s6," ",s7," print*,"=================================================================================================" ",s8
esta ltima impresso das 4 linhas como ficar no seu cdigo fonte as linhas citadas. Observe como ficou difcil (desconfortvel) ler as linhas com fonte no pequenas. Por isto no usamos este tamanho de fonte.
10. Entidade do Tipo Caractere

Uma entidade caractere (objeto de dado tipo caractere) pode ser visualizada como sendo uma caixa contendo vrias divises, onde cada diviso pode guardar um caractere. Por exemplo, considere a varivel tipo caractere abc definida assim:
character(len=4):: abc = "raiz"
esta instruo cria (separa; reserva) uma parte da memria do computador e atribui a esta poro da memria um nome, neste caso o nome abc. Agora toda vez que se utilizar o nome abc estamos nos referindo a (trabalhando com) esta parte da memria. A memria do computador reservada para a varivel caractere pode ser visualizada como sendo uma caixa subdividida da seguinte forma:
posio de memria que est sendo chamada de abc r a i z
Observe que a instruo de definio da varivel caractere reserva 4 posies para abc, isto , esta varivel caractere poder conter at quatro caracteres (ela tem exatamente um tamanho de 4 caracteres).
41
Cada posio na entidade caractere numerada para que os valores guardados nela possam ser individualmente acessados. A numerao feita de forma que a posio mais a esquerda a posio nmero 1. Ento:
abc
abc
valor: r posio:
1
a 2
i 3
z 4
ENTRANDO VALORES MAIORES QUE O TAMANHO DA VARIVEL O que ocorre quando o tamanho do contedo (valor) e o tamanho da varivel so diferentes? Quando o tamanho da varivel caractere menor que o tamanho do que se quer guardar nela, o valor guardado cortado. Veja o exemplo:
program ent_01 !----------------------------------------!Exemplo de entrada de valor caractere com !tamanho maior que a varivel caractere !AUTOR: Anibal L. Pereira 26/06/2010 !----------------------------------------implicit none character(len=4):: var1 print*,"Entre nome com tamanho maior que 4" read*, var1 print*,"var1 contm o valor: ", var1 end program ent_01
O programa ent_01 cria uma varivel caractere chamada var1 que tem um tamanho igual a 4 solicita que o usurio entre com um nome contendo mais de 4 caracteres guarda o nome fornecido pelo usurio na varivel caractere var1 depois mostra na tela do micro o valor contido (guardado) na varivel caractere
Copie o programa e execute-o para ver sua sada. Quando se entra, por exemplo, com o valor encontrar a sada do programa ser:
len=4 var1 = "encontrar" e n c o n t r a r
enco
observe que os caracteres excedentes foram cortados, ficando apenas os caracteres enco. ENTRANDO VALORES MENORES QUE O TAMANHO DA VARIVEL Para o caso do valor que ser guardado na varivel caractere ser menor que o tamanho da varivel, as posies da varivel que no receberem caracteres sero preenchidas com o caractere branco. Por exemplo, veja o caso da varivel var2 de tamanho 12 que receba um valor de tamanho 9:
len=12 var2 = "encontrar" e n c o n t r a r
Observe que existem 9 caracteres diferentes de branco e 3 brancos para perfazer o tamanho 12 da varivel.
42
CONTANTE LITERAL CARACTERE As constantes literais caracteres tem sempre exatamente o tamanho que for especificado, isto , o tamanho entre as aspas ou apstrofos que delimitam a constante. Ento:
"Entre nome com tamanho maior que 4"
tem exatamente 34 caracteres, contando com os caracteres brancos existentes na constante.

"Escreva seu nome: "
contm 18 caracteres (contando com o brando colocado no final do string) CONTANTE COM NOME CARACTERE A constante com nome caractere tambm tem sempre exatamente o tamanho da expr-inicializao utilizada na sua definio. Ento:
character(len=*), parameter:: mes="abril" mes
tem um tamanho de 5 caracteres, enquanto
character(len=*), parameter:: mes9="setembro" mes9
contm 8 caracteres
11. Substring
Porque um substring (subcadeia de caractere), e tambm uma varivel caractere, uma cadeia de caracteres numerada da esquerda para a direita possvel trabalhar com cada caractere individualmente. A forma geral de um substring : onde:
string-origem
string-origem(intervalo-substring)
especifica o string origem, isto , o string que fornecer os caracteres para o substring do tipo i:f onde i e f so inteiros positivos que especifica o ponto inicial e o ponto final do substring
intervalo-substring
Um substring uma poro de um caractere. Usando um substring possvel trabalhar com parte de uma varivel ou constante caractere. Recorde que um substring referenciado utilizando-se o nome do string origem seguido pela indicao, entre parnteses, da posio inicial e posio final. Por exemplo:
implicit none character(len=34):: var var="Entre nome com tamanho maior que 4" print*, var(1:5)
a varivel var tem tamanho de 34 caracteres e o valor

Entre nome com tamanho maior que 4
a instruo print ir imprimir na tela do micro apenas a palavra

Entre
porque o substring utilizado est usando apenas as 5 primeiras posies da varivel caractere var, que gera o valor Entre
43
E 1
n 2
t 3
r 4
e 5 6
n 7
o 8
m 9
.. .. .. .. q
10 11 12 13 14 15 .. .. .. .. 30 31 32 33 34
print*, var(12:14) print*, var(7:14) print*, var(3:5) print*, var(34:34) print*, var(10:10) print*, var
mostra na tela do micro: com mostra na tela do micro: nome com mostra na tela do micro: tre mostra na tela do micro: 4 mostra na tela do micro: e (o valor guardado na posio 34) (valor na posio 10)
mostra na tela do micro: Entre nome com tamanho maior que 4 porque no um substring a prpria varivel
12. Operador Concatenao

O nico operador que existe para se trabalhar com objetos do tipo caractere o operador concatenao. Concatenar significa colocar ao lado, juntar. No Fortran, o operador concatenao representado por // (duas barras juntas). O que ele faz? Simplesmente junta os strings. O segmento de programa que segue, gera a sada mostrada nos quadros:
character(len=5):: primeiro = "Maria" character(len=9):: segundo = "Antonieta" character(len=15):: duplo1, duplo2 duplo1 = primeiro//segundo duplo2 = primeiro//" "//segundo print*,'duplo1 ==> print*,'duplo2 ==> ', duplo1 ', duplo2
As instrues e o resultado que elas geram na tela do micro: print*,'duplo1 ==> ', duplo1
duplo1 ==>
MariaAntonieta
Observe que o operador concatenao no coloca espaos entre o que est sendo concatenado. Se isto for necessrio, o programador tem que providenciar isto.
print*,'duplo2 ==> ', duplo2
duplo2 ==>
Maria Antonieta
13. Descritor de Formato Alfanumrico

Usa-se os descritores de edio de formato para controlara a aparncia dos dados. Por exemplo, a instruo uma das formas mais simples de utilizar um formato. Neste caso o formato lista dirigida que usualmente chamamos de formato livre, que indicado por um asterisco ( * ).
print*
44
A instruo print tem a seguinte forma: onde:

formatos lista
print formatos, lista
especifica os formatos que sero utilizados com as entidades na lista Identifica as entidades (objetos) que sero escritas
O descritor de edio de formato para dados do tipo caractere o descritor alfanumrico, que tem a seguinte forma:
A[w]
a de alfanumrico este descritor de edio de formato utilizado para formatar o dado do tipo caractere ( controlar a sua aparncia). Ele indicado pela letra a (ou a letra maiscula A). Aw a letra A tanto pode ser escrita maiscula quanto minscula, o w indica o tamanho do campo utilizado, isto , um nmero inteiro que indica quantos caracteres o campo pode conter Exemplo: o descritor de formato a10 ou A10 identificam um campo de 10 caracteres (10 posies). FATOR DE REPETIO O descritor de edio alfanumrico pode ser multiplicado por um nmero inteiro que representa a quantidade de repeties do descritor. Este nmero deve aparecer antes do descritor. Exemplo: 5A3 o mesmo que escrever cinco vezes o descritor de formato A3:
program exemplo_f !----------------------------------------!-- Programa exemplo de formatao !-- AUTOR: Anibal L. Pereira 19/07/2010 !----------------------------------------implicit none character(len=20):: nome1 character(len=13):: nome2 character(len=6)::numero nome1="Entre com um nmero" nome2=" maior que 20" print"(a33)", nome1//nome2 read*, numero print"(2a6)", numero,numero end program exemplo_f
A3, A3, A3, A3, A3
Ao executar o programa e entrar com o nmero 2345, a sada ser igual a mostrada abaixo:
Entre com um nmero maior que 20 2345 2345 2345
Inconveniente
A contagem dos caracteres deve levar em conta a seguinte peculiaridade: Porque a lngua inglesa no usa acentos e c-cedilha (o Fortran no disponibiliza estes caracteres no seu conjunto de caracteres), a tabela ASCII (o conjunto de caracteres default do Fortran) possu todos os caracteres necessrios lngua inglesa. Entretanto, este no o nosso caso. Para o Fortran, os caracteres so guardados internamente como nmeros binrios de 32 bits. Por exemplo: o caractere k (a letra k minscula) na tabela ASCII o nmero 107 (decimal) que escrito em binrio : 00000000000000000000000001101011 que usualmente escrevemos assim: 1101011 Como o maior valor existente na tabela ASCII padro o valor decimal 127 ( em binrio: 1111111 ) e porque o padro Fortran estabelece que os caracteres usados por um programa devem utilizar uma codificao compatvel com o conjunto de caracteres default do Fortran (na prtica o ASCII), os caracteres utilizados pelo Fortran so sempre nmeros menores que 127.
45
E o nosso caso? Resumindo uma histria longa, nosso smbolos (acentos, cedilha, e outros caracteres que no existem na tabela ASCII) so escritos usando mais de um octeto (1 byte) [a codificao utilizada chamada de UTF-8, que usa de 1 a 4 octetos (1 a 4 bytes): detalhes podem ser vistos em: http://en.wikipedia.org/wiki/UTF-8 ]. Por exemplo, os caracteres , , e so representados pelas seguintes pares de valores: 195 173 195 181 195 169 195 167 Observe que estes caracteres usam dois nmeros (dois octetos dois bytes). Como o compilador Fortran usa apenas 1 nmero (um octeto) para cada caractere, ele vai trabalhar os nmeros 195 e 173 como dois caracteres (2 octetos) no um nico caractere. Por isto o compilador vai ter problema com o udo do 195 e do 173 para representar um nico caractere. Ele vai trabalhar estranhamente ou ento, em certos casos, acusar erro. Soluo: O padro Fortran 2003 que permite o uso de caracteres da tabela unicode (caracteres no pertencentes lngua inglesa) nas variveis e constantes literais do tipo caractere, resolve (resolve parcialmente) este problema. No momento no vamos abordar o uso da tabela unicode, porque isto envolveria vrios detalhes que desviariam a ateno do que mais importante para ns, no momento. Ento, para lidar com este evento, vamos adotar um truque:
Truque:
encontrando um caracteres no ASCII, (nossos caso) ele (geralmente) escrito usando 2 octetos (2 bytes mas, dependendo do caractere representado pode conter at 4 octetos entretanto, para ns 2 octetos o caso mais comum), por isto conte uma posio a mais para cada caractere no padro encontrado. Assim voc poder usar um campo de tamanho adequado para a entidade. Exemplo:
"Entre com um nmero" print"(a19)", "Entre com um nmero" gera uma sada truncada ==> print"(a20)", "Entre com um nmero" gera a sada correta ==> Entre com um nmero porque o u acentuado conta como dois octetos no um como s tem um caractere no ASCII, a contagem aumentou apenas de uma unidade. Portanto a20 suficiente para no truncar a sada Entre com um nmer <== este string contm 19 caracteres
14. Descritores de Formato Tabulador

As formas gerais dos descritores de tabulao so: Tc TRn TLn T c TR TL n representa o tabulador indica a coluna tabulador a direita da posio atual tabulador a esquerda da posio atual quantas posies ou colunas (absoluto) (relativo) (relativo)
Com o tabulador possvel andar para a direita e para a esquerda dentro da linha. Para modificar a forma como os dados iro aparecer numa linha ( aparncia do dado) pode-se usar os tabuladores. importante lembrar que:
46
cada declarao print (ou write) imprime uma linha portanto andar na vertical feito com a declarao print
os tabuladores permitem andar na horizontal (dentro da linha)
Tudo ficar mais fcil se voc tratar a tela do micro como uma tabela contendo linhas e colunas (Quadro 1).
c1 Linha 1 Linha 2 Linha 3 Linha 4 Linha 5 ...... ...... ...... c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 c19 c20 ... ... ...
Quadro 1 Visualizao da tela do micro em linhas e colunas Exemplo:

print"(a)","primeira cadeia de caracteres" print"(4a)","pri ","seg ","ter ","quar" print"(4a4)","pri ","seg ","ter ","quar" print"(4a)","um ","dois ","trezentos ","quar" print"(a3,a4,a10,a4)","um ","dois","trezentos ","quar" Resultado: primeiro cadeia de caracteres pri seg ter quar pri seg ter quar um dois trezentos quar um dois trezentos quar
15. Descritor de Formato Posicional

A forma geral deste descritor : onde: X insere espaos a direita da posio atual nX n quantidade de espaos Exemplo:
print"(5X,a,5X,a)", print"(6X,a,6X,a)", print"(7X,a,7X,a)", print"(8X,a,8X,a)", print"(9X,a,9X,a)", Resultado: primeira segunda primeira segunda primeira segunda primeira segunda primeira segunda "primeira","segunda" "primeira","segunda" "primeira","segunda" "primeira","segunda" "primeira","segunda"
47
16. Funes Intrnsecas Caractere

As funes intrnsecas caractere so as funes do Fortran 2003 que permitem implementar vrias aes quando se trabalha com caracteres. Elas esto listadas no quadro que segue.
Funo
achar(i) adjustl(string) adjustr(string) char(i[,kind])
Descrio
retorna o caractere na posio i da sequncia de caracteres ASCII i um nmero inteiro inteiro para caractere ajusta a esquerda brancos vo para o final (direita) do campo ajusta a direita brancos vo para o incio (frente) do campo retorna o caractere na posio i da sequncia de caracteres do processador i um nmero inteiro inteiro para caractere retorna a posio do caractere na sequncia ASCII c um caractere caractere para inteiro retorna a posio do caractere na sequncia do processador c um caractere caractere para inteiro retorna a posio inicial do substring no string back, faz a procura do substring iniciando do fim para o incio retorna o comprimento de uma entidade caractere tamanho do campo do string ou nmero de caracteres existentes na constante literal caractere retorna o comprimento sem caracteres brancos posteriores lexicalmente maior que ou igual a string_A string_B lexicalmente maior que string_A > string_B lexicalmente menor que ou igual a string_A string_B lexicalmente menor que string_A < string_B faz concatenao repetida concatena n cpias do string retorna a primeira posio no string de um dos caractere existente em set remove caracteres brancos posteriores retorna a primeira posio no string para um caractere que no existe em set
iachar(c) ichar(c) index(string,substring[,back]) len(string)
len_trim(string) lge(string_A, string_B) lgt(string_A, string_B) lle(string_A, string_B) llt(string_A, string_B) repeat(string,ncopies) scan(string, set[,back]) trim(string) verify(string,set[,back])
17. Instruo IF
A instruo if muito til na escrita de programas, porque permite ao programa executar ou no uma instruo, conforme o resultado de uma avaliao.
48
Instruo IF
Executando ou no uma instruo
program escreve_isto_ou_aquilo !------------------------------------!Exemplo de controle de fluxo !AUTOR: Anibal L. Pereira 29/07/2010 !------------------------------------implicit none character(len=5):: var1="Ol," character(len=8):: var2="Bom dia," character(len=1):: escolha print*,"Entre com A ou B:" read*, escolha
Este programa solicita um dado do usurio ( a letra A maiscula ou a letra B maiscula) e baseado no valor fornecido pelo usurio executa uma instruo ou no. Ao execut-lo, entrando com a opo A o programa escreve na tela o seguinte:
Entre com A ou B: A
Ol, para voc !-----------------------------------------! escolhe o que imprimir na tela do micro !------------------------------------------ executando novamente opo B obtm-se: print* if(escolha == "A") print*,var1//" para voc" if(escolha == "B") print*,var2//" para voc" Entre com A ou B: print* B end program escreve_isto_ou_aquilo Bom dia, para voc
o programa e escolhendo a
A instruo if:
o teste o teste est colocado entre parnteses a varivel escolha comparada com a constante literal A a comparao indicada pelo operador == (dois sinais de igual juntos)
if(escolha == "A") then
se o teste gerar o valor verdadeiro (T = true = verdadeiro), isto , se a varivel caractere escolha contiver o caractere A a instruo print*,var1//" para voc" executada
se o teste for falso se o teste gerar o valor falso (F = false = falso), isto , se a varivel caractere escolha contiver um valor diferente do caractere A a instruo print*,var1//" para voc" no executada
Aps a execuo da instruo if (conforme a condio seja verdadeira ou falsa) o fluxo do programa segue para a prxima instruo no programa.
49
18. Arquivo
Escrever dados em um arquivo ou ler dados de um arquivo, uma tarefa bastante comum. O procedimento a ser seguido para ler ou escrever em um arquivo :
1. conectar (abrir) o arquivo com as especificaes desejadas 2. ler (read) ou escrever (write) dados no arquivo 3. fechar (close) o arquivo, quando ele no mais necessrio
A instruo para conectar (abrir) um arquivo tem a seguinte forma:
open(unit=U, file="arq", status="S", action="A")
onde: U um nmero inteiro, geralmente maior ou igual a 10 e menor que 99 O programador deve, arbitrariamente, escolher o nmero inteiro que vai utilizar. Este inteiro deve ser nico, isto , no pode ser utilizado em outra instruo open, no mesmo programa, enquanto esta unidade no foi fechada (liberada para uso). o nome do arquivo, que deste momento em diante ser identificada pelo unidade especificada. Quando existir a necessidade de referencia ao arquivo, utiliza-se a unidade. pode ser: OLD NEW REPLACE
arq
para arquivo j existente para arquivo novo (arquivo ser criado; arquivo no pode existir) para sobrescrever o arquivo (contedo original ser perdido; se o arquivo no existir ser criado)
pode ser: READ arquivo ser conectado apenas para leitura WRITE arquivo ser conectado apenas para escrita READWRITE arquivo ser conectado para leitura e escrita Considere a existncia do arquivo de dados chamado poema.dados que contm o seguinte texto:
Exemplo:
POEMA: Amor fogo que arde sem se ver Amor fogo que arde sem se ver; ferida que di e no se sente; um contentamento descontente; dor que desatina sem doer; um no querer mais que bem querer; solitrio andar por entre a gente; nunca contentar-se de contente; cuidar que se ganha em se perder;
querer estar preso por vontade; servir a quem vence, o vencedor; ter com quem nos mata lealdade. Mas como causar pode seu favor Nos coraes humanos amizade, Se to contrrio a si o mesmo Amor? Lus de Cames
50
Ento a abertura (conexo) do arquivo pode ser feita assim:

open(unit=30, file="poema.dados", status="old", action="read")
19. Instruo Write

O Fortran possui a instruo print e e a instruo write. A instruo print possibilita escrever na tela do micro. S na tela do micro. A instruo write escreve na tela do micro e tambm escreve em outro dispositivo. Na tela ou em outro dispositivo.
Escrevendo na tela do micro:

Por exemplo, as instrues:
print*, "Entre com um nmero" write(unit=*, fmt=*) "Entre com um nmero"
implementam a mesma ao, isto , escreve na tela do micro a mesma mensagem: "Entre com um nmero" Quando a unidade unit= identificada por um asterisco (*) a tela do micro ser utilizada. Portanto print* e write(unit=* tem o mesmo significado e podem ser utilizados indistintamente.
print*, "Entre com um nmero" write(unit=*, fmt=*) "Entre com um nmero" !<-- mais simples de escrever !<-- um pouco mais complexo para escrever
Aps um arquivo de dados ter sido conectado (aberto) possvel se trabalhar com o arquivo, ou seja, pode-se ler dados do arquivo ou escrever dados no arquivo. A instruo para ler dados num arquivo a instruo read. Enquanto a instruo de escrita no arquivo a instruo write.
Escrevendo num arquivo:
depois da conexo do arquivo poema.dados

open(unit=50, file="poema.dados", status="replace", action="readwrite")
possvel escrever uma linha no arquivo poema.dados, que est sendo (neste caso) identificado pela unidade 50. O valor (contedo) da linha que ser escrita est guarda na varivel caractere linha_sendo_escrita.
write(unit=50, fmt=*) linha_sendo_escrita
Observe que o formato (abreviado por fmt=) utilizado o formato livre, o que est caracterizado pelo caractere * (asterisco).
51
20. Instruo Read

O Fortran possui a instruo read utilizada para leitura de dados. Tanto do teclado quanto de um dispositivo.
Lendo do teclado:
As instrues:
read*, linha read(unit=*, fmt=*) linha
implementam a mesma ao: l dado fornecido pelo teclado Quando a unidade unit= identificada por um asterisco (*) o teclado o dispositivo que est sendo utilizado. Portanto read* e read(unit=* tem o mesmo significado e podem ser utilizados indistintamente.
read*, linha read(unit=*, fmt=*) linha !<-- mais simples de escrever !<-- um pouco mais complexo para escrever
Aps um arquivo de dados ter sido conectado (aberto) possvel se trabalhar com o arquivo, ou seja, pode-se ler dados do arquivo.
Lendo de um arquivo:
por exemplo, depois da conexo do arquivo poema.dados

open(unit=30, file="poema.dados", status="old", action="read")
possvel ler uma linha no arquivo poema.dados, que est sendo (neste caso) identificado pela unidade 30. O valor (contedo) da linha lida ser guarda na varivel caractere linha_do_arquivo.
read(unit=30, fmt=*) linha_do_arquivo
Observe que o formato (abreviado por fmt=) utilizado o formato livre, o que est caracterizado pelo caractere * (asterisco).
21. Instruo Close

Quando todas as aes necessrios e/ou desejadas foram realizadas com o arquivo conectado, pode-se desconectar (fechar liberar) o arquivo. Para isto usa-se a instruo close.
close(unit=50)
Depois de fechado o arquivo no pode mais ser acessado. Depois de fechado (da unidade ter sido liberada) a unidade pode ser utilizada para conectar o mesmo ou ento outro arquivo.
program ex_01 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso de arquivo !--------------------------------------------------------------------------------------! Arquivo: ex_01.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=40)::linha1, linha2, linha3, linha4, linha5, linha6 character(len=11)::arquivo="poema.dados"
52
!-----------------------------------------------------------------! conecta o arquivo com o poema para leitura !-----------------------------------------------------------------open(unit=10, file="poema.dados", status="old", action="read") !-----------------------------------------------------------------! l as 6 primeira linha do arquivo !-----------------------------------------------------------------read(unit=10, fmt="(a40)") linha1 read(unit=10, fmt="(a40)") linha2 read(unit=10, fmt="(a40)") linha3 read(unit=10, fmt="(a40)") linha4 read(unit=10, fmt="(a40)") linha5 read(unit=10, fmt="(a40)") linha6 !-----------------------------------------------------------------! fecha o arquivo !-----------------------------------------------------------------close(unit=10) !---------------------------------------------------------------------! mostra na tela do micro as 4 primeiras linhas do poema, usando PRINT !---------------------------------------------------------------------print* print*,"QUATRO LINHAS DO "//linha1 print*,linha2 print*,linha3 print*,linha4 print*,linha5 print*,linha6 print*,"----------------------------------------------" print*,"----------------------------------------------" !---------------------------------------------------------------------! mostra na tela do micro as 4 primeiras linhas do poema, usando WRITE !---------------------------------------------------------------------write(unit=*,fmt=*) write(unit=*,fmt="(t12,a57)")"QUATRO LINHAS DO "//linha1 write(unit=*,fmt="(t12,a40)")linha2 write(unit=*,fmt="(t12,a40)")linha3 write(unit=*,fmt="(t12,a40)")linha4 write(unit=*,fmt="(t12,a40)")linha5 write(unit=*,fmt="(t12,a40)")linha6 write(unit=*,fmt="(t12,a40)") write(unit=*,fmt=*) end program ex_01
EXEMPLOS DE USO DAS FUNES INTRNSECAS Execute os exemplos para ver seu funcionamento.
Consulte detalhes sobre as funes intrnsecas no link da Home Page. Alguns destes exemplos utilizam o descritor de formato para nmero inteiro: quando se utiliza o descritor de formato I, isto significa que se est formatando um nmero inteiro. Ento: I2 significa usar, no mximo, 2 posies no nmero inteiro I3 significa usar, no mximo, 3 posies no nmero inteiro
53
Consulte a tabela ASCII para conferir a sada do programa program ex_02 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes intrnsecas achar e char ! achar ==> SEQUNCIA ASCII char ==> SEQUNCIA PROCESSADOR !--------------------------------------------------------------------------------------! Arquivo: ex_02.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none print* print*,"I print"(4a)","33 print"(4a)","34 print"(4a)","35 print"(4a)","36 print"(4a)","37 print"(4a)","38 print"(4a)","39 print"(4a)","40 print* achar --> --> --> --> --> --> --> --> char" ", achar(33), ", achar(34), ", achar(35), ", achar(36), ", achar(37), ", achar(38), ", achar(39), ", achar(40),
" " " " " " " "
", ", ", ", ", ", ", ",
char(33) char(34) char(35) char(36) char(37) char(38) char(39) char(40)
end program ex_02 Consulte a tabela ASCII para conferir a sada do programa program ex_03 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes intrnsecas iachar e ichar ! iachar ==> SEQUNCIA ASCII ichar ==> SEQUNCIA DO PROCESSADOR !--------------------------------------------------------------------------------------! Arquivo: ex_03.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none print* print*,"C iachar ichar" print"(a,i2,a,i2)","A --> ", print"(a,i2,a,i2)","B --> ", print"(a,i2,a,i2)","C --> ", print"(a,i2,a,i2)","D --> ", print"(a,i2,a,i2)","a --> ", print"(a,i2,a,i2)","b --> ", print"(a,i2,a,i2)","c --> ", print"(a,i3,a,i3)","d --> ", print* end program ex_03
iachar("A"), iachar("B"), iachar("C"), iachar("D"), iachar("a"), iachar("b"), iachar("c"), iachar("d"),
" " " " " " " "
", ichar("A") ", ichar("B") ", ichar("C") ", ichar("D") ", ichar("a") ", ichar("b") ", ichar("c") ", ichar("d")
program ex_04 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes intrnsecas adjustl e adjustr !--------------------------------------------------------------------------------------! Arquivo: ex_04.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=50):: linha
54
linha="Entre com uma letra" print* print"(a50)"," 1 2 3 4 5" print"(a50)","12345678901234567890123456789012345678901234567890" print"(a50)",linha print"(a50)",adjustr(linha) print* print*,"A rgua foi colocada apenas para facilitar a visualizao das colunas" print*,"observe como a linha est ajustada a esquerda e depois a direita" print* print*,"Veja agora a manipulao da constante literal 'de' " print* print*,"Casa ", " de ", " madeira!" print*,"Casa ", adjustr(" de "), " madeira!" print*,"Casa ", adjustl(" de "), " madeira!" print* end program ex_04 program ex_05 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes intrnsecas index !--------------------------------------------------------------------------------------! Arquivo: ex_05.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=19):: linha linha="Entre com uma letra" print* print"(a)"," 1111111111" print"(a)","1234567890123456789" print"(a19)",linha print* print"(a,i2)"," 'uma' inicia na posio ",index(linha,"um") print* print"(a,i2)"," 'com' inicia na posio ",index(linha,"com") print* end program ex_05 program ex_06 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes intrnsecas len e len_trim !--------------------------------------------------------------------------------------! Arquivo: ex_06.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=19):: linha1 character(len=40):: linha2 linha1="Entre com uma letra" linha2="Nova linha agora com tamanho 31" print* print"(a)"," 1111111111222222222233333333334" print"(a)","1234567890123456789012345678901234567890" print"(a19)",linha1 print"(a40)",linha2 print*

print"(a,i2)","tamanho de linha1 = ", len(linha1) print"(a,i2)","tamanho de linha2 = ", len(linha2) print* print"(a,i2)","posies usadas na linha1 = ", len_trim(linha1) print"(a,i2)","posies usadas na linha2 = ", len_trim(linha2) print* end program ex_06 program ex_07 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes intrnsecas trim !--------------------------------------------------------------------------------------! Arquivo: ex_07.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=19):: nome print*,"Entre com seu nome" read*,nome print* print"(a)"," 1111111111222222222233333333334" print"(a)","1234567890123456789012345678901234567890" print"(a)","ol, "//nome//", como vai?" print"(a)","ol, "//trim(nome)//", como vai?" print* end program ex_07
55
Ordem de arrumao Sequncia de arrumao Ordenao

As funes LLE, LGE, LGT e LLT so funes que permitem verificar a arrumao dos caracteres do Fortran (a arrumao dos caracteres: quando os caracteres forem somente letras o que chamamos de ordem alfabtica). sequncia de arrumao: em ingls: collating sequence Cada caractere do conjunto de caracteres do Fortran est arrumado numa lista onde cada caractere tem um peso (uma ordem um nmero de posio). No existem dois pesos iguais. O Fortran utiliza apenas 95 caracteres (95 52 letras + 10 dgitos + 1 caractere sublinha + 32 caracteres especiais), entretanto o computador que voc est usando, provavelmente tem mais caracteres disponveis ( o cdigo ASCII possu 128 caracteres sendo que somente 94 so caracteres imprimveis. Se outro cdigo for usado mais valores podem estar disponveis). Nas mquinas que utilizam 95 caracteres os pesos dos caracteres variam de 0 a 94. Geralmente o conjunto de caracteres utilizado o ASCII, mas para as mquinas que utilizam o conjunto padro default do Fortran a regra a seguinte:
as funes intrnsecas char e ichar provm o mecanismo para a converso entre os caracteres e os inteiros (pesos) usados na sequncia do processador (computador em uso) Exemplo: ichar('d') retorna o valor inteiro referente ao caractere d para a sequncia padro default do Fortran (collating sequence) as regras que se aplicam so: 1. ichar('A')<ichar('B')<... <ichar('Z') para as 26 letras maisculas 2. ichar('0')<ichar('1')<... <ichar('9') para os 10 dgitos 3. ichar(' ')<ichar('0')<... <ichar('9')<ichar('A') ou
4. 5.
ichar(' ')<ichar('A')<ichar('Z')<ichar('0') ichar('a')<ichar('b')<... <ichar('z') para ichar(' ')<ichar('0')<ichar('9')<ichar('a') ou ichar(' ')<ichar('a')<ichar('z')<ichar('0')
as 26 letras minsculas
Exceto para o caractere branco, no h restries para a localizao dos caracteres especiais e o sublinha.
56
Na prtica o conjunto de caracteres adotado pelo Fortran o ASCII. A partir do padro Fortran 2003, o conjunto de caracteres adotado pode ser o UNICODE o que torna muito mais amigvel o uso do Fortran.
program ex_08 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes lle, lge, lgt e llt !--------------------------------------------------------------------------------------! Arquivo: ex_08.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=3):: st1="one", st2="two" print* print*,"Lexicamente maior ou igual a ==> lge" print*,"Lexicamente maior que ==> lgt" print*,"Lexicamente menor ou igual a ==> lle" print*,"Lexicamente menos que ==> llt" print* print*,"T = TRUE e F = FALSE" print* print* , "o resultado de lle('a','b') ", lle('a','b') print* , "o resultado de lle('b','a') ", lle('b','a') print* , "o resultado de lle('B','a') ", lle('B','a') print* , "o resultado de lle('a','a') ", lle('a','a') print* print* , 'o resultado de llt("one","two") ', llt("st1","st2") print* , "o resultado de llt('ONE','TWO') ", llt('ONE','TWO') print* , "o resultado de llt('one','TWO') ", llt('one','TWO') print* , "o resultado de llt('s','m') ", llt('s','m') print* print* , "o resultado de lge('sa','ma') ", lge('sa','ma') print* , "o resultado de lgt('sag','sbg') ", lgt('sag','sbg') print* end program ex_08 program ex_09 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes intrnsecas repeat !--------------------------------------------------------------------------------------! Arquivo: ex_09.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=19):: nome print*,"Entre com seu nome" read*,nome print* print"(a)","ol, print"(a)","ol, print* print"(a)","ol, print"(a)","ol, print* end program ex_09 "//nome//". "//"Como"//" Vai ?" "//nome//". "//repeat("Como ",3)//repeat("Vai ",3)//"?" "//trim(nome)//". "//"Como"//" Vai ?" "//trim(nome)//". "//repeat("Como ",3)//repeat("Vai ",3)//"?"
57
program ex_10 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes intrnsecas scan !--------------------------------------------------------------------------------------! Arquivo: ex_10.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=33)::texto="Escreva uma frase, contendo carro" print* print*,"Identifica a primeira posio em que uma dos caracteres listados aparece no string" print*,"A frase que est sendo usada :===> ""Escreva uma frase, contendo carro"" " print* print"(a)"," 1111111111222222222233333333334" print"(a)","1234567890123456789012345678901234567890" print"(a)", texto print* print"(a,i2)", "yaq -->",scan(texto, "yaq") print* print"(a,i2)", "eyz -->",scan(texto, "eyz") print* print"(a,i2)", "yqE -->",scan(texto, "yqE") print* print"(a,i2)", "m --> ",scan(texto, "m") print* end program ex_10 program ex_11 ! !--------------------------------------------------------------------------------------! Propsito: exemplo simples de uso das funes intrnsecas verify !--------------------------------------------------------------------------------------! Arquivo: ex_11.f03 ! Autor: Anibal L. Pereira 08/02/2011 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=33)::texto="Escreva uma frase, contendo carro" print* print*,"Identifica a primeira posio em que uma dos caracteres listados NO aparece no string" print*,"Frase usada :===> ""Escreva uma frase, contendo carro"" " print*," Veja se h diferena entre letra maiscula e minscula" print* print"(a)"," 1111111111222222222233333333334" print"(a)","1234567890123456789012345678901234567890" print"(a)", texto print* print"(a,i2)", "aeiou -->",verify(texto, "aeiou") print* print"(a,i2)", "AEIOU -->",verify(texto, "AEIOU") print* print"(a,i2)", "AEIOUscrv -->",verify(texto, "AEIOUscrv") print* end program ex_11
58
Atividade 14
Entregar em meio magntico: 1. programa: decoracao_01 decoracao_01.f03
Exemplo:
O programa decoracao_01 mostra como um texto pode ser modificado e decorado
Voc pode copiar e colar os cdigos fontes, mas no deixe de ajustar a diagramao dos cdigos fontes segundo o estilo de programao adotado na disciplina No deixe de atualizar o cabealho do programa de forma adequada. ________________________________________________________________________________________ arquivo: decoracao_01.f03
program decoracao_01 ! !--------------------------------------------------------------------------------------! Propsito: Programa simples que faz uso de: ! ! constante com nome caractere ! varivel caractere ! operador concatenao ! as funes intrnsecas caractere ! -- repeat ! -- trim ! descritor de formato alfanumrico ! repetio do descritor A ! tabulador absoluto ! instruo IF !--------------------------------------------------------------------------------------! Arquivo: decoracao_01.f03 ! Autor: Anibal L. Pereira 29/07/2010 !Revises: Anibal L. Pereira 15/02/2011 ! !--------------------------------------------------------------------------------------implicit none character(len=15):: a1_n1, & ! primeira parte do nome do aluno 1 a1_n2, & ! segunda parte do nome a1_n3, & ! terceira ... a1_n4, & ! ... a1_n5, & ! ... a1_n6 ! sexta parte do nome character(len=3)::deco ! decorao em uso character(len=*),parameter::pp1="===", & ! decorao 1 pp2="*=*", & ! decorao 2 pp3="(*)", & ! decorao 3 pp4="GGG", & ! decorao 4 pp5="&&&" ! decorao 5 !-----------------------------------------------------------------------------------! escolha do tipo de decorao a ser usada na mensagem de instruo !-----------------------------------------------------------------------------------!deco=pp1 ! faa a escolha do tipo de decorao a ser usada removendo o !deco=pp2 ! comentrio em apenas uma das instruo de atribuio da varivel deco !deco=pp3 ! execute o programa algumas vezes, escolhendo decoraes diferentes deco=pp4 !deco=pp5 !------------------------------------------------------------------------------! mensagem inicial !------------------------------------------------------------------------------print* print"(a)", repeat(deco,26) print"(2a,t77,a)",deco," Voc deve entrar com um nome composto de 6 partes:",deco

print"(a,t76,a)", deco,deco print"(2a,t77,a)",deco," Ao entrar com o nome de um aluno, caso no existam",deco print"(2a,t76,a)",deco," seis entradas no nome, complete com w ",deco print"(2a,t77,a)",deco," tantos w's quanto necessrio para ter 6 partes", deco print"(a,t76,a)", deco,deco print"(2a,t77,a)",deco," Exemplo: Joo da Silva", deco print"(2a,t77,a)",deco," Joo da Silva w w w ",deco print"(a)", repeat(deco,26) print* !------------------------------------------------------------------------------! Entrada do nome do aluno !------------------------------------------------------------------------------print*,"Entre com o nome do primeiro aluno:" read*, a1_n1, a1_n2, a1_n3, a1_n4, a1_n5, a1_n6
59
!------------------------------------------------------------------------------! Mostrando na tela do micro !------------------------------------------------------------------------------! Observe que a sada apresenta uma aparncia desagradvel quando: ! (1) no se elimina os brancos dos nomes ! (2) no se elimina os W's dos nomes print* print"(a)", repeat(pp1,26) print*,"Escrevendo a mesma mensagem vrias vezes com tratamento diferentes" print"(a)", repeat(pp1,26) print* ! print"(a,a)","Entre com as notas P1 e P2 do aluno: ",a1_n1//a1_n2//a1_n3//a1_n4//a1_n5//a1_n6 ! print* print"(a,a)","Entre com as notas P1 e P2 do aluno: ",& trim(a1_n1)//trim(a1_n2)//trim(a1_n3)//trim(a1_n4)//trim(a1_n5)//trim(a1_n6) ! print* print"(a,a)","Entre com as notas P1 e P2 do aluno: ",& trim(a1_n1)//" "//trim(a1_n2)//" "//trim(a1_n3)//" "//trim(a1_n4)& &//" "//trim(a1_n5)//" "//trim(a1_n6) !-------------------------------------------------------! fazendo as variveis ficarem vazias: para o w minsculo ! ! a comparao entre os objetos feita com os ! dois sinais de iguais: == ! os dois iguais representam um teste, uma pergunta ! por exemplo: A == B ! significa A igual a B ? !-------------------------------------------------------if(a1_n3 == "w") a1_n3 = "" if(a1_n4 == "w") a1_n4 = "" if(a1_n5 == "w") a1_n5 = "" if(a1_n6 == "w") a1_n6 = "" !-------------------------------------------------------! para o W maisculo !-------------------------------------------------------if(a1_n3 == "W") a1_n3 = "" if(a1_n4 == "W") a1_n4 = "" if(a1_n5 == "W") a1_n5 = "" if(a1_n6 == "W") a1_n6 = "" ! print* print"(2a)","Entre com as notas P1 e P2 do aluno: ",& trim(a1_n1)//" "//trim(a1_n2)//" "//trim(a1_n3)//" "//trim(a1_n4)& &//" "//trim(a1_n5)//" "//trim(a1_n6) print* end program decoracao_01
60
Atividade 15
Entregar em meio magntico: 1. programa: decoracao_02 decoracao_02.f03
Exemplo/Acrscimo/Ajuste:
O programa decoracao_02 mostra como um texto escrito na tela do micro com um arranjo tal que os nomes dos elementos aparecem alinhados a esquerda na tabela.
<=><=><=><=><=><=><=><=><=><=><=><=><=><=> <=> 123456789012345 123456789012345 <=> <=> cobre 60% <=> <=> magnsio 2% <=> <=> hidrognio 13% <=> <=> zircnio 5% <=> <=> molibdnio 10% <=> <=> radnio 10% <=> <=><=><=><=><=><=><=><=><=><=><=><=><=><=>
Escreva os cdigos (modificando o programa) que: 1. mostre o mesmo quadro, mas utilizando o tabulador relativo TR
2. utilize a funo intrnseca caractere adjustr de forma que a sada seja similar a
<=><=><=><=><=><=><=><=><=><=><=><=><=><=> <=> 123456789012345 123456789012345 <=> <=> cobre 60% <=> <=> magnsio 2% <=> <=> hidrognio 13% <=> <=> zircnio 5% <=> <=> molibdnio 10% <=> <=> radnio 10% <=> <=><=><=><=><=><=><=><=><=><=><=><=><=><=>
isto , a coluna com os nomes dos elementos fique justificada a direita (alinhada direta) Observao: a decorao utilizada pode ser a de sua escolha 3. mostre o mesmo quadro, mas utilizando o descritor de formato posicional X No deixe de atualizar o cabealho do programa de forma adequada. ________________________________________________________________________________________ arquivo: decoracao_02.f03
program decoracao_02 ! !--------------------------------------------------------------------------------------! Propsito: Programa simples que escreve uma tabela e faz uso de: ! ! variveis caracteres ! constante com nome caractere ! substring ! funo intrnsecas caractere adjustr, repeat ! !--------------------------------------------------------------------------------------! Arquivo: decoracao_02.f03 ! Autor: Anibal L. Pereira 29/07/2010 !Revises: !--------------------------------------------------------------------------------------implicit none character(len=15):: n1="cobre", & ! 6 nomes n2="magnsio", & ! n3="hidrognio", & !

n4="zircnio", n5="molibdnio", n6="radnio", num1="60%", num2=" 2%", num3="13%", num4=" 5%", num5="10%", num6="10%" & & & & & & & & ! ! ! ! 6 nmeros ! ! ! ! ! decorao em uso decorao decorao decorao decorao decorao decorao 1 2 3 4 5 6
61
character(len=3)::deco ! character(len=*),parameter::u10="1234567890" character(len=*),parameter::pp1="===", & ! pp2="*=*", & ! pp3="(*)", & ! pp4="<=>", & ! pp5="xxx", & ! pp6="FFF" !
!-----------------------------------------------------------------------------------! escolha do tipo de decorao a ser usada !-----------------------------------------------------------------------------------!deco=pp1 !deco=pp2 !deco=pp3 deco=pp4 !deco=pp5 !deco=pp6 !------------------------------------------------------------------------------! mensagem inicial !------------------------------------------------------------------------------print* print"(a)", repeat(deco,14) print"(a,t5,a,t15,a,t22,a,t32,a,t40,a)", deco,u10,u10(1:5),u10,u10(1:5),deco print"(a,t5,a,t22,a,t40,a)",deco,n1,num1,deco print"(a,t5,a,t23,a,t41,a)",deco,n2,num2,deco print"(a,t5,a,t23,a,t41,a)",deco,n3,num3,deco print"(a,t5,a,t23,a,t41,a)",deco,n4,num4,deco print"(a,t5,a,t23,a,t41,a)",deco,n5,num5,deco print"(a,t5,a,t23,a,t41,a)",deco,n6,num6,deco print"(a)", repeat(deco,14) print* !------------------------------------------------------------------------------! Usando a tabulao relativa TR !------------------------------------------------------------------------------!(*)remova estas linhas !(*)escreva aqui os cdigos que reproduza a mesma sada, mas usando o tabulador relativo !------------------------------------------------------------------------------! Usando a funo intrnseca caractere adjustr !------------------------------------------------------------------------------!(*)remova estas linhas !(*)escreva aqui os cdigos referentes a mesma sada, mas usando o adjustr !------------------------------------------------------------------------------! Usando o descritor de formato posicional X !------------------------------------------------------------------------------!(*)remova estas linhas !(*)escreva aqui os cdigos que reproduza a mesma sada, mas usando o descritor de formato ! posicional X end program decoracao_02
62
Atividade 16
Entregar em meio magntico: 1. programa: dia_semana dia_semana.f03
Fazer:
Escreva um programa que: 1. solicite que o usurio entre com um dos seguinte nome segunda tera quarta quinta sexta sbado domingo 2. escreva na tela do micro uma mensagem similar a: O dia da semana que voc entrou foi: segunda-feira O programa deve escrever o dia da semana que o usurio escolheu. Todos, menos sbado e domingo, tero agregado a expresso -feira ao nome escolhido. Use o operador concatenao. Obrigatrio: A expresso -feira tem que estar definida numa constante com nome caractere.
Atividade 17
Entregar em meio magntico: 1. programa: funcoes_caractere funcoes_caractere.f03
Exemplo/Acrscimo/Ajuste:
Modifique o programa funcoes_caractere de forma que: os cdigos acrescentados permitam ao programa realizar a mesma tarefa, mas utilizando funes intrnsecas caractere diferentes: verify achar iachar char ichar O programa deve fazer a mesma coisa sempre, mas utilizando funes intrnsecas diferentes. No deixe de atualizar o cabealho do programa de forma adequada. ________________________________________________________________________________________ arquivo: funcoes_caractere.f03
program funcoes_caractere ! !---------------------------------------------------------------------------------------! Propsito: Programa simples que intenciona mostra o uso de algumas funes intrnsecas ! caractere !---------------------------------------------------------------------------------------! Arquivo: funcoes_caractere.f03 ! Autor: Anibal L. Pereira 29/07/2010

!Revises: !---------------------------------------------------------------------------------------implicit none character(len=21)::frase, & ! frase do usurio c1="impossvel possvel", & ! primeira combinao c2="possvel impossvel", & ! segunda combinao ce ! combinao fornecida !-----------------------------------------------------------------------------------! Define um valor default para a varivel caractere ce !-----------------------------------------------------------------------------------ce = c2 !-----------------------------------------------------------------------------------! entrada da combinao escolhida pelo usurio !-----------------------------------------------------------------------------------print* print*,"--------------------------------------------------------" print*,"Como existe um espao em branco entre as duas palavras" print*,"voc tem que entrar o texto todo " print*,"entre aspas ( "" ) ou ento entre apstrofo ( ' )" print*,"--------------------------------------------------------" print* print*,"Entre com o texto: impossvel possvel" print*," ou ento: possvel impossvel" print* read*, frase !-----------------------------------------------------------------------------------! identifica qual combinao foi fornecida pelo usurio ! se foi a primeira combinao, troca o valor de ce ! ! aqui se utiliza a funo intrnseca caractere scan para localizar a ! posio do caractere i no valor fornecido. A combinao fornecida pelo ! teclado pode ser identificada pela posio do i: se ela for a posio 1 ! a combinao s pode ter sido: impossvel possvel ! ! claro que aqui admite-se que no houve erro na digitao ! do valor que est sendo fornecido !-----------------------------------------------------------------------------------if(scan(frase,"i") == 1) ce=c1 !-----------------------------------------------------------------------------------! mostra o resultado na tela do micro !-----------------------------------------------------------------------------------print*,"Voc entrou com: ", ce !@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ !!!!!!!!!!!! escreva e coloque a partir daqui os cdigos necessrios para a utilizao !!!!!!!!!!!! das funes intrnsecas caractere especificadas !@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ !-----------------------------------------------------------------------------------! usando a funo verify !-----------------------------------------------------------------------------------<coloque aqui os cdigos> !-----------------------------------------------------------------------------------! usando a funo achar !-----------------------------------------------------------------------------------<coloque aqui os cdigos> !-----------------------------------------------------------------------------------! usando a funo iachar !-----------------------------------------------------------------------------------<coloque aqui os cdigos> !-----------------------------------------------------------------------------------! usando a funo char !------------------------------------------------------------------------------------
63
64
<coloque aqui os cdigos> !-----------------------------------------------------------------------------------! usando a funo ichar !-----------------------------------------------------------------------------------<coloque aqui os cdigos> end program funcoes_caractere

Fiscomp FA-01 2011-1

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Fiscomp FA-01 2011-1

Uploaded by

Copyright:

Available Formats

Instituto de Fsica Armando Dias Tavares Departamento de Fsica Aplicada e Termodinmica

Primeiros Programas: constantes e variveis tipo caractere

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

2. Primeiro Programa em Fortran

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

Esta Folha contm 17 Atividades

Seu professor de laboratrio (e/ou teoria) poder alterar esta relao !

O processo para escrever, compilar e executar um programa envolve os seguintes passos:

O passo-a-passo que segue ajudar na implementao da tarefa.

O nome do diretrio criado ser similar a: 03filipe01

Turma: 03 Aluno: filipe Folha de Atividades: 01

(use somente letras minsculas)

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

Para criar o diretrio de trabalho, abra o navegador de arquivo:

Escreva o nome do diretrio (por exemplo: 03anibal01).

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

comando pwd no prompt do terminal execute o comando pwd

no terminal, escreva pwd seguido de um espao em branco e pressione a tecla <enter>

listando o contedo do diretrio de trabalho no prompt do terminal, digite o comando ls -l

(-l menos letra ele, no menos um)

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

e pressione a tecla <enter>

Ateno: escreva o comando exatamente como mostrado:

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

O que fazer quando o compilador encontra erro(s)

Editor gedit e um terminal

Reforando o entendimento do processo de compilao

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

3.1. Para treinar

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

(main-program unit) (module unit) (external-subprogram unit) (block-data program unit)

A figura que segue evidencia as melhores formas de se pensar um programa em Fortran.

Programa Principal (caso mais simples)

Programa Principal e um Mdulo (caso comum)

Programa Principal e vrios Mdulos (muito til)

Melhores formas de se pensar um programa Fortran

Unidade de programa dados em bloco

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

As principais caractersticas de um subprograma externo, no Fortran 2003, so:

subprograma externo escrito em Fortran

subprograma externo escrito em outra lngua de programao

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

As seguintes caractersticas devem ser observadas:

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

6. Conjunto de Caracteres do Fortran 2003

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

as letras minsculas so equivalentes as letras maisculas, exceto no contexto caractere.

DIGITOS os 10 dgitos so:

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

TABELA ASCII baseada na tabela existente em: http://www.hobbyprojects.com/ascii-table/ascii-table.html (em 27/07/2010)

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

velocidade massa15 massa_do_corpo nome_muito_longo_que_nao_esta_errado

Os seguintes anos no so bissextos:

Escrever o programa fonte Compilar o programa Executar o programa

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

As caractersticas importantes a serem destacadas so:

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere

DFAT/Folha Atividades/FiscompFA Primeiros Programas: constantes e variveis tipo caractere