Centro Universitário de Maringá - CESUMAR
Cursos de AUTOMAÇÃO INDUSTRIAL e
ENGENHARIA DE CONTROLE E AUTOMAÇÃO
Disciplina de Informática para Automação
Prof. EE. Carlos Henrique Z. Pantaleão
2005
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Guias e Dicas
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Encontrar documentos
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Encontra documentos específicos para os exames da tua universidade
Encontra documentos específicos para os exames da tua universidade
Videoaulas
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Quiz
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Linguagem de Programação C, Notas de estudo de Engenharia Metalúrgica
Curso básico de Linguagem de Programação em C
Tipologia: Notas de estudo
Antes de 2010
1 / 126
Esta página não é visível na pré-visualização
Não perca as partes importantes!
Documentos relacionados
Pré-visualização parcial do texto
Baixe Linguagem de Programação C e outras Notas de estudo em PDF para Engenharia Metalúrgica, somente na Docsity!
Centro Universitário de Maringá - CESUMAR
Cursos de AUTOMAÇÃO INDUSTRIAL e
ENGENHARIA DE CONTROLE E AUTOMAÇÃO
Disciplina de Informática para Automação Prof. EE. Carlos Henrique Z. Pantaleão
Prof. Carlos Pantaleão
- 1 Programação em C........................................................................................................................... SUMÁRIO
- 2 Conceitos Básicos da Programação C.............................................................................................
- 2.1 Histórico de C......................................................................................................................
- 2.2 Criando um Programa Executável.......................................................................................
- 2.3 A Estrutura Básica de um Programa em C..........................................................................
- 2.4 Variáveis............................................................................................................................
- 2.5 Tipos de Dados...................................................................................................................
- 2.6 Constantes..........................................................................................................................
- 2.7 Ponteiros.............................................................................................................................
- 2.8 Exercícios...........................................................................................................................
- 3 Entrada/Saída Console...................................................................................................................
- 3.1 Printf()……........................................................................................................................
- 3.2 Cprintf()………………………………….........................................................................
- 3.3 Scanf()..........................................…............……..............................................................
- 3.4 Getch(), Getche() e Getchar()……....................................................................................
- 3.5 Putch() ou Putchar()...........................................................................................................
- 3.6 Exercícios...........................................................................................................................
- 4 Operadores .....................................................................................................................................
- 4.1 Operadores Aritméticos.....................................................................................................
- 4.2 Operadores Relacionais......................................................................................................
- 4.3 Operadores lógicos binários...............................................................................................
- 4.4 Operadores de Ponteiros....................................................................................................
- 4.5 Operadores Incrementais e Decrementais..........................................................................
- 4.6 Operadores de Atribuição..................................................................................................
- 4.7 O Operador Lógico Ternário..............................................................................................
- 4.8 Precedência........................................................................................................................
- 4.9 Exercícios...........................................................................................................................
- 5 Laços.................................................................................................................................................
- 5.1 O Laço For.........................................................................................................................
- 5.2 O Laço While.....................................................................................................................
- 5.3 O Laço Do-While...............................................................................................................
- 5.4 Break e Continue.........................................................……...............................................
- 5.5 Goto....................................................................................................................................
- 5.6 Exercícios...........................................................................................................................
- 6 Comandos para Tomada de Decisão............................................................................................. Prof. Carlos Pantaleão
- 6.1 If………….........................................…............................................................................
- 6.2 If-Else..…….......................................................................................................................
- 6.3 Switch…….........................................................................................................................
- 6.4 Exercícios.................……..................................................................................................
- 7 Funções ............................................................................................................................................
- 7.1 Sintaxe................................................................................................................................
- 7.2 Exemplos............................................................................................................................
- 7.3 Prototipagem......................................................................................................................
- 7.4 Classes de Armazenamento...............................................................................................
- 7.4.1 Auto.…................………....................................................................................
- 7.4.2 Extern.........................................……….............................................................
- 7.4.3 Static....................................................................................................................
- 7.4.4 Variáveis Estáticas Externas...............................................................................
- 7.4.5 Register................................................................................................................
- 7.5 Exercícios...........................................................................................................................
- 8 Diretivas do Pré-Processador.........................................................................................................
- 8.1 Diretiva #define..................................................................................................................
- 8.2 Macros................................................................................................................................
- 8.3 Diretiva #undef..................................................................................................................
- 8.4 Diretiva #include................................................................................................................
- 8.5 Compilação Condicional....................................................................................................
- 8.6 Operador defined................................................................................................................
- 8.7 Diretiva #error....................................................................................................................
- 8.8 Diretiva #pragma ...............................................................................................................
- 8.9 Exercícios...........................................................................................................................
- 9 Matrizes...........................................................................................................................................
- 9.1 Sintaxe de Matrizes............................................................................................................
- 9.2 Inicializando Matrizes........................................................................................................
- 9.3 Matrizes como Argumentos de Funções............................................................................
- 9.4 Chamada Por Valor e Chamada Por Referência................................................................
- 9.5 Strings .....................................................................……..................................................
- 9.5.1 Strings Constantes.....................................…......................................................
- 9.5.2 String Variáveis...................................................................................................
- 9.5.3 Funções para Manipulação de Strings.................................................................
- 9.6 Exercícios...........................................................................................................................
- 10 Tipos Especiais de Dados............................................................................................................. Prof. Carlos Pantaleão
- 10.1 Typedef............................................................................................................................
- 10.2 Enumerados (Enum)........................................................................................................
- 10.3 Estruturas (Struct)............................................................................................................
- 10.4 Uniões..............................................................................................................................
- 10.5 Bitfields............................................................................................................................
- 10.6 Exercícios.........................................................................................................................
- 11 Ponteiros e a Alocação Dinâmica de Memória...........................................................................
- 11.1 Declaração de Ponteiros e o Acesso de Dados com Ponteiros.........................................
- 11.2 Operações com Ponteiros.................................................................................................
- 11.3 Funções & Ponteiros........................................................................................................
- 11.4 Ponteiros & Matrizes.....................................................................................................
- 11.5 Ponteiros & Strings........................................................................................................
- 11.6 Ponteiros para Ponteiros.................................................................................................
- 11.7 Argumentos da Linha de Comando...............................................................................
- 11.8 Ponteiros para Estruturas...............................................................................................
- 11.9 Alocação Dinâmica de Memória....................................................................................
- 11.9.1 Malloc().......................………........................................................................
- 11.9.2 Calloc()....................................………............................................................
- 11.9.3 Free()...............................................................................................................
- 11.10 Exercícios.....................................................................................................................
- 12 Manipulação de Arquivos em C................................................................................................
- 12.1 Tipos de Arquivos..........................................................................................................
- 12.2 Declaração, abertura e fechamento................................................................................
- 12.3 Leitura e escrita de caracteres........................................................................................
- 12.4 Fim de Arquivo (EOF)...................................................................................................
- 12.5 Leitura e escrita de strings.............................................................................................
- 12.6 Arquivos Padrões..........................................................................................................
- 12.7 Gravando um Arquivo de Forma Formatada.................................................................
- 12.8 Leitura e escrita de valores binários...............................................................................
- 12.9 Exercícios.......................................................................................................................
Prof. Carlos Pantaleão
1 Programação em C
Atualmente, empregam-se cada vez mais sistemas computacionais na automatização de processos industriais. Os sistemas computacionais empregados variam desde um simples circuito lógico digital, passando por uma circuito composto por um microprocessador ou um CLP, até sistemas complexos envolvendo um ou mais microcomputadores ou até estações de trabalho. Um engenheiro que atua nesta área deve conhecer os sistemas computacionais disponíveis e ser capaz de selecionar o melhor equipamento para uma dada aplicação. Além disto, este profissional deve conseguir instalar este sistema, configurá-lo e acima de tudo programá-lo para que este execute a tarefa de automatização atendendo os requisitos industrias do sistema, como imunidade a falhas ou comportamento determinístico com restrições temporais (sistemas tempo-real). Neste contexto, a programação destes sistemas se faz de suma importância. Basicamente, a inteligência dos sistemas automatizados é implementada através de programas computacionais, comandando os componentes de hardware para executar a tarefa com o comportamento desejado.
Figura 1 - Comparação entre os diversos sistemas computacionais para aplicações industriais.
Nas últimas décadas, o desenvolvimento em hardware permitiu que cada vez mais os processos industrias sejam automatizados e interligados através de sistemas computacionais. Entretanto, a evolução em software não se deu em tamanha velocidade como a de hardware. Desta
Prof. Carlos Pantaleão
Desta forma, os compiladores requerem o uso adicional de um editor de ligações ( "Linker" ), que combina módulos-objetos ( "Traduzidos" ) separados entre si e converte os módulos assim "linkados" no formato carregável pelo sistema operacional (programa .EXE ).
2 Conceitos Básicos da Programação C
2.1 Histórico de C
O compilador "C" vem se tornando o mais difundido em ambiente industrial. A linguagem "C" se originou das linguagens BCPL e B desenvolvidas em 1970. A primeira versão de "C" foi implementada para o sistema operacional UNIX pela Bell Laboratories , especificamente por Dennis M. Ritchie e Ken Thompson no início da década de 70, e rodava em um DEC PDP11 ( Digital Equipment Corporation ). A linguagem “C” foi utilizada para portar o UNIX para outros computadores. A linguagem "C" possui uma característica dual:
- É considerada linguagem estruturada de alto-nível;
- Assembly de alto-nível, que permite escrever programas muito próximos à linguagem de máquina, sendo usada para desenvolver muitas aplicações como compiladores, interpretadores, processadores de texto e mesmo sistemas operacionais. Ex: UNIX, MSDOS, TPW.
A linguagem de programação “C” tornou-se rapidamente uma das mais importantes e populares, principalmente por ser muito poderosa, portátil, pela padronização dos compiladores existentes (através da norma ANSI C) e flexível. Os programas em “C” tendem a ser bastante compactos e de execução rápida. A linguagem “C” é baseada em um núcleo pequeno de funções e estruturas básicas, desta forma, todo programa é desenvolvido a partir deste núcleo básico. Isto implica na grande portabilidade de “C”, haja vista que basta a implementação deste núcleo básico para um dado processador e automaticamente já estará disponível um compilador “C” para este processador. Por esta razão, existem compiladores “C” para a grande parte dos sistemas computacionais atualmente disponíveis. Devido também a este pequeno núcleo, um programador C é capaz de desenvolver
Prof. Carlos Pantaleão
programas tão eficientes, pequenos e velozes quanto os programas desenvolvidos em Assembly. Por isso, diz-se que C é uma linguagem de alto nível, porém, próxima da linguagem de máquina.
2.2 Criando um Programa Executável
Primeiro, escreva o seu programa (arquivo em modo ASCII), com o auxílio de um programa denominado de compilador, e grave o programa em disco dando a ele um nome como sufixo .C. O programa gerado é chamado de código fonte. Na seqüência, compile o fonte seguindo as instruções do seu compilador, o que criará um programa com o sufixo .OBJ em disco. O programa gerado é chamado de objeto. Por fim, basta linkeditar o objeto seguindo as instruções do seu linkeditor o que criará um programa com sufixo .EXE em disco. O programa gerado é chamado de executável. A Figura 2 apresenta o processo de geração de um programa em C.
Figura 2 - Ilustração do processo de criação de um programa em C.
Prof. Carlos Pantaleão
biblioteca “stdio” e irá linká-la posteriormente ao programa. Desta forma, você poderá usufruir todos os serviços disponíveis nesta biblioteca. Por fim, temos a função “main()”. Esta função indica ao compilador em que instrução deve ser começada a execução do programa. Portanto, esta função deve ser única, aparecendo somente uma vez em cada programa. O programa termina quando for encerrada a execução da função main(). No caso deste programa exemplo, ela não recebe nenhum parâmetro e também não retorna parâmetro nenhum. Isto fica explícito através da palavra-chave void escrita na frente do programa. Se em vez de void tivéssemos escrito int, isto significaria que a função main() deveria retornar um valor do tipo inteiro ao final de sua execução. Como este é o valor retornado pela função main(), este também será o valor retornado pelo programa após a sua execução. As funções e as suas características serão apresentadas em detalhes nos próximos capítulos. Todo o corpo de uma função em C é inicializado e finalizado através das chaves { e }. Estas chaves definem o bloco de instruções a serem executados por esta função. A primeira instrução dada dentro do programa é “printf (“Bom Dia!!!!”);”. Printf é uma função definida em “stdio.h” para escrever dados na janela console. Todas as instruções de programa têm que ser declaradas dentro de alguma função (na main() ou outra qualquer). Todas as instruções devem estar dentro das chaves que iniciam e terminam a função e são executadas na ordem em que as escrevemos. As instruções C são sempre encerradas por um ponto-e-vírgula ( ; ). O ponto-e-vírgula é parte da instrução e não um simples separador. Esta instrução é uma chamada à função printf(), os parênteses nos certificam disso e o ponto-e-vírgula indica que esta é uma instrução. Nota-se que a função é chamada escrevendo-se o nome desta e colocando-se os parâmetros desta dentro dos parênteses. A final de cada instrução, faz-se necessário o acréscimo de um ponto-vírgula “;”. As variáveis em C podem estar dentro de uma função ou no início do arquivo fonte. Variáveis declaradas no início do arquivo fonte são consideradas “globais”, isto é, são visíveis (acessíveis) para todas as funções do programa. Variáveis declaradas dentro de uma função são consideradas “locais”, isto é, visíveis somente pela função onde são declaradas. "C" distingue nomes de variáveis e funções em maiúsculas de nomes em minúsculas. Você pode colocar espaços, caracteres de tabulação e pular linhas à vontade em seu programa, pois o compilador ignora estes caracteres. Em C não há um estilo obrigatório. Entretanto, procure manter os programas tão organizados quanto for possível, pois isto melhora muito a legibilidade do programa, facilitando o seu entendimento e manutenção.
Prof. Carlos Pantaleão
2.4 Variáveis
As variáveis são o aspecto fundamental de qualquer linguagem de computador. Uma variável em C é um espaço de memória reservado para armazenar um certo tipo de dado e tendo um nome para referenciar o seu conteúdo. O espaço de memória de uma variável pode ser compartilhado por diferentes valores segundo certas circunstâncias. Em outras palavras, uma variável é um espaço de memória que pode conter, a cada tempo, valores diferentes.
/* Programa : Exemplo de variáveis! / #include <stdio.h> void main() { int num; / declaracao / num = 2; /atribui um valor/ printf(“Este é o número dois: %d”, num); /acessa a variável*/ }
A primeira instrução (int num) é um exemplo de declaração de variável, isto é, apresenta um tipo, int , e um nome, num. A segunda instrução (num = 2 ) atribui um valor à variável e este valor será acessado através de seu nome. Usamos o operador de atribuição (=) para este fim. A terceira instrução chama a função printf() mandando o nome da variável como argumento. Esta lê o valor da variável e substitui na posição indicada por %d , compondo assim a frase apresentada na tela. O emprego da função printf() será apresentado em detalhe, posteriormente. Em C todas as variáveis devem ser declaradas. Se você tiver mais de uma variável do mesmo tipo, poderá declará-las de uma única vez separando seus nomes por vírgulas. Exemplo:
int aviao, foguete, helicoptero;
Prof. Carlos Pantaleão
Observação: As declarações que aparecem na tabela acima entre parênteses (), indicam que estas declarações são optativas. Por exemplo “short unsigned int” indica a mesma precisão que “unsigned int”. O tipo int tem sempre o tamanho da palavra da máquina, isto é, em computadores de 16 bits ele terá 16 bits de tamanho. Emprega-se o complemento de dois dos números positivos para o cálculo e representação dos números negativos. A escolha de nomes significativos para suas variáveis pode ajudá-lo a entender o que o programa faz e prevenir erros. Uma variável não pode ter o mesmo nome de uma palavra-chave de C. Em C, letras minúsculas e maiúsculas são diferentes.
Exemplo de um programa que emprega as variáveis apresentadas.
void main() { float y; /variável Real não inicializada/ int i; /variável Inteira não inicializada/ double x = 3.24; /*var. Double inicializada com 3.24 / char c = 'a'; /variável Char inicializada com a / i = 100; /variável i recebe o valor 100 / y = (float) i; /converte tipos */ }
Preste atenção na operação “y= (float) i;”. Esta operação é muita empregada para conversão de tipos de variáveis diferentes. Suponha que você tenha uma variável ‘x’ de tipo A e queira
Prof. Carlos Pantaleão
convertê-la para o tipo B e armazená-la em y deste tipo. Você pode executar esta operação através do operador: y = ((B) x);
Atenção: Cuidado ao converter variáveis com precisão grande para variáveis com precisão pequena, ou seja, variáveis que utilizam um número diferente de bits para representar dados. Você pode perder informações importantes por causa desta conversão. Por exemplo, se você converter um float num int, você perderá todos os dígitos depois da vírgula (precisão).
void main() { float y = 3.1415; int x = 0; x = (int) y; /* Equivalente à: x = 3 */ }
2.6 Constantes
Um constante tem valor fixo e inalterável. No primeiro programa exemplo, mostramos o uso de uma cadeia de caracteres constante juntamente com a função printf(): printf(“Bom Dia!!!!”);
Há duas maneiras de declarar constantes em C: a) usando a diretiva #define do pré-processador: #define < nome da constante > < valor >
Esta diretiva faz com que toda aparição do nome da constante no código seja substituída antes da compilação pelo valor atribuído. Não é reservado espaço de memória no momento da declaração define. A diretiva deve ser colocada no inicio do arquivo e tem valor global (isto é, tem valor sobre todo o código). Exemplo:
Prof. Carlos Pantaleão
2.7 Ponteiros
Uma das mais poderosas características oferecidas pela linguagem C é o uso de ponteiros. Um ponteiro proporciona um modo de acesso a variáveis sem referenciá-las diretamente. O mecanismo usado para isto é o endereço da variável. De fato, o endereço age como intermediário entre a variável e o programa que a acessa. Basicamente, um ponteiro é uma representação simbólica de um endereço. Portanto, utiliza- se o endereço de memória de uma variável para acessá-la. Um ponteiro tem como conteúdo um endereço de memória. Este endereço é a localização de uma outra variável de memória. Dizemos que uma variável aponta para uma outra quando a primeira contém o endereço da segunda. A declaração de ponteiros tem um sentindo diferente da de uma variável simples. A instrução: int *px;
declara que *px é um dado do tipo int e que px é um ponteiro, isto é, px contém o endereço de uma variável do tipo int. Para cada nome de variável (neste caso px ), a declaração motiva o compilador a reservar dois bytes de memória onde os endereços serão armazenados. Além disto, o compilador deve estar ciente do tipo de variável armazenada naquele endereço; neste caso inteiro. O endereço de uma variável pode ser passado à um ponteiro através do operador &, como apresentado abaixo:
void main() { int num, valor; /* declara as variáveis como inteiras / int ptr; / declara um ponteiro para um inteiro / ptr = 0; / inicializa o ponteiro com o endereco ‘0’ / ptr = # / atribui ao ptr o endereço da variável num/ num = 10; /* atribui à variável inteira o valor ‘10’ */ valor = ptr; / acessa o conteúdo apontado por ‘ptr’ e / / atribui a ‘valor’ */ }
Prof. Carlos Pantaleão
Neste programa, primeiro declaram-se duas variáveis inteiras. Em seguida, declara-se um ponteiro para uma variável do tipo inteira. Este ponteiro tem o seu conteúdo inicializado com ‘0’. Este é um procedimento normal na manipulação de ponteiros, muito empregado para evitar o aparecimento de erros. Pois, enquanto o endereço de um ponteiro for nulo, isto indicará que este endereço contém um valor inválido e, portanto, o conteúdo representado por este endereço não deve ser acessado. Na seqüência, emprega-se o operador & para obter o endereço da variável ‘num’ e armazenar este endereço em ‘ptr’. Logo após, atribuímos a variável inteira ‘num’ o valor 10. Como ‘ptr’ contém o endereço de ‘num’, logo ‘ptr’ poderá já acessar o valor 10 armazenado na variável ‘num’. Isto é feito na última linha, onde o conteúdo apontado por ‘ptr’ é acessado e copiado para a variável ‘valor’. Outro exemplo da manipulação de ponteiros:
void main() { int i, j, ptr; / declara as variáveis / i = 1; / i recebe o valor ‘1’ / j = 2; / j recebe o valor ‘2’ / ptr = &i; / ptr recebe o valor do endereço de i */ *ptr = ptr + j; / equivale a: i = i + j */ }
Nosso objetivo neste momento não é apresentar todas as potencialidades dos ponteiros. Estamos aqui apresentando os ponteiros primeiramente como um tipo de dado especial. O importante aqui é entender o conteúdo de um ponteiro e como este pode ser empregado. Posteriormente, apresentaremos as funcionalidades dos ponteiros à medida que formos evoluindo no aprendizado de C.
Prof. Carlos Pantaleão
3 Entrada/Saída Console
As rotinas de entrada/saída do console se encontram nas bibliotecas "stdio.h" e "conio.h" e, por isso, estas bibliotecas devem ser incluídas nos programas aplicativos através da diretiva ‘include’: #include <stdio.h> #include <conio.h>
Algumas das funções de entrada e saída para a console mais utilizadas são apresentadas a seguir:
3.1 Printf()
A função printf()é uma das funções de E/S (entrada e saída) que podem ser usadas em C. Ela não faz parte da definição de C mas todos os sistemas têm uma versão de printf() implementada. Ela permite a saída formatada na tela. Já vimos duas aplicações diferentes da função printf():
printf(“Bom Dia!!!!”); printf(“Este é o número dois: %d”, num);
A função printf() pode ter um ou vários argumentos. No primeiro exemplo nós colocamos um único argumento: “Bom Dia !!!!”. Entretanto, no segundo colocamos dois: “Este é o número dois: %d” que está à esquerda e o valor 2 à direita da vírgula que separa os argumentos. Sintaxe de printf(): printf(“string-formatação“, < lista de parâmetros >);
A string de formatação pode conter caracteres que serão exibidos na tela e códigos de formatação que indicam o formato em que os argumentos devem ser impressos. No nosso segundo exemplo, o código de formatação %d solicita a printf() para imprimir o segundo argumento em formato decimal na posição da string onde aparece o %d. Cada argumento deve ser separado por uma vírgula.
Prof. Carlos Pantaleão
Além do código de formatação decimal ( %d ), printf() aceita vários outros. O próximo exemplo mostra o uso do código %s para imprimir uma cadeia de caracteres:
#include <stdio.h> int main(int argc, char* argv[]) { printf(“%s esta a %d milhoes de milhas \n do sol.”, “Venus”, 67); }
A saída será: Venus está a 67 milhoes de milhas do sol.
Aqui, além do código de formatação, a expressão de controle de printf() contém um conjunto de caracteres estranho: \n. O \n é um código especial que informa a printf() que o restante da impressão deve ser feito em uma nova linha. A combinação de caracteres \n representa, na verdade, um único caractere em C, chamado de nova-linha (equivalente ao pressionamento da tecla ‘Enter’ em um editor de texto). Os caracteres que não podem ser obtidos diretamente do teclado para dentro do programa (como a mudança de linha) são escritos em C, como a combinação do sinal \ (barra invertida) com outros caracteres. Por exemplo, \n representa a mudança de linha. A string de formatação define a forma como os parâmetros serão apresentados e tem os seguintes campos: "%[Flags] [largura] [.precisão] [FNlh] < tipo > [\Escape Sequence]" onde: