Ud2
Upcoming SlideShare
Loading in...5
×
 

Ud2

on

  • 864 views

 

Statistics

Views

Total Views
864
Views on SlideShare
863
Embed Views
1

Actions

Likes
0
Downloads
1
Comments
0

1 Embed 1

http://www.slideshare.net 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Ud2 Ud2 Presentation Transcript

  • Unidade Didática II Estrutura de um Programa em C
  • Uma linguagem de programação é um método padronizado para expressar instruções para um computador. É composto por um conjunto de regras sintáticas e semânticas que definem o programa a ser executado pelo computador. Este conjunto de regras formam um conjunto de palavras (tokens) e constituem o código fonte. Esse código fonte é depois traduzido para código de máquina, que é executado pelo processador.
  • Linguagens de programação são projetadas para adotar uma sintaxe de nível mais alto a qual permite um fácil entendimento por programadores humanos. View slide
  • Quanto à geração: Primeira geração, as linguagens de baixo nível (Assembly) Segunda geração, as primeiras linguagens (Fortran, ALGOL,...) Terceira geração, as procedurais e estruturadas (Pascal, C). Quarta geração, linguagens que geram programas em outras linguagens (Java, C++), linguagens de consulta (SQL). Quinta geração, linguagens lógicas (Prolog). View slide
  • A linguagem C
  • Criada por Dennis Ritchie (1972) Bell Laboratories. Primeira utilização importante: reescrita do SO UNIX (escrito em assembly). Em 1980 já existiam várias versões de compiladores C oferecidas por várias empresas, não sendo mais restritas apenas ao ambiente UNIX (compatíveis com outros SO). O C é uma linguagem de propósito geral, sendo adequada à programação estruturada.
  • A linguagem C pertence a uma família de linguagens cujas características são: Portabilidade Modularidade Compilação separada Recursos de baixo nível Geração de código eficiente Confiabilidade Regularidade Simplicidade Facilidade de uso.
  • Visão geral de um programa C: A geração do programa executável a partir do programa fonte obedece a uma seqüência de operações antes de tornar-se um executável. Depois de escrever o módulo fonte em um editor de textos, o programador aciona o compilador (p. ex. gcc). Essa ação desencadeia uma seqüência de etapas, cada qual traduzindo a codificação do usuário para uma forma de linguagem de nível inferior, que termina com o executável criado pelo lincador.
  • Editor (módulo fonte em C) Pré-processador (novo fonte expandido) Compilador (arquivo objeto) Lincador (executável)
  • Sintaxe: São regras detalhadas para cada construção válida na linguagem C. Estas regras estão relacionadas com os tipos, as declarações, as funções e as expressões. Os tipos definem as propriedades dos dados manipulados em um programa.
  • As declarações expressam as partes do programa, podendo dar significado a um identificador, alocar memória, definir conteúdo inicial, definir funções. As funções especificam as ações que um programa executa quando roda. São as entidades operacionais básicas dos programas em C, que por sua vez são a união de uma ou mais funções executando cada qual o seu trabalho. Há funções básicas que estão definidas na biblioteca C.
  • As funções printf() e scanf() por exemplo, permitem respectivamente escrever na tela e ler os dados a partir do teclado. O programador também pode definir novas funções em seus programas, como rotinas para cálculos, impressão, etc. Todo programa C inicia sua execução chamando a função main(), sendo obrigatória a sua declaração no programa principal.
  • Comentários no programa são colocados entre /* e */ não sendo considerados na compilação. Cada instrução encerra com ; (ponto e vírgula) que faz parte do comando.
  • EXEMPLO: #include <stdio.h> /* Pacotes c/ funções de entrada e saída */ #include <math.h> /* Este pacote é desnecessário, mas mostra podem ser adicionados outros pacotes */ int main(void) { printf("Olá, Mundo!n"); return 0; /* Retorna 0, pois main retorna um int */ } /* Nova linha após fechar a chave principal */
  • A estrutura de um programa em C: A estrutura genérica de um programa em C apresenta a seguinte forma, podendo alguns dos elementos não existir: * Comandos do pré-processador . * Definições de tipos . * Protótipos de funções - declaração dos tipos de retorno e dos tipos dos parâmetros das funções . * Variáveis globais . * Funções.
  • O pré-processador: O pré-processador C é um programa que examina o programa fonte escrito em C e executa certas modificações nele, baseado nas diretivas de compilação (ou diretivas do pré- processador). As diretivas de compilação são comandos que não são compilados, sendo dirigidos ao pré- processador, executado pelo compilador antes da execução do processo de compilação propriamente dito.
  • O pré-processador modifica o programa fonte, que ainda não estaria pronto para ser entregue ao compilador. Todas as diretivas de compilação são iniciadas pelo caractere #. As diretivas podem ser colocadas em qualquer parte do programa, mas não podem ser colocadas na mesma linha que outra diretiva ou instrução.
  • As principais diretivas de compilação são: #include #define #undef #ifdef #ifndef #if #else #elif #endif
  • Bibliotecas em C: A biblioteca padrão de C é um conjunto de rotinas padronizadas da linguagem C que contém operações comuns como por exemplo tratamentos de entrada/saída e cadeia de caracteres. Padronização: ANSI – 1983 ANSI C.
  • stdio.h (extrato): /* * stdio.h * This file has no copyright assigned and is placed in the Public Domain. * This file is a part of the mingw-runtime package. * No warranty is given; refer to the file DISCLAIMER within the package. * * Definitions of types and prototypes of functions for standard input and * output. * * NOTE: The file manipulation functions provided by Microsoft seem to * work with either slash (/) or backslash () as the directory separator. * */
  • stdio.h (extrato): /* * The three standard file pointers provided by the run time library. * NOTE: These will go to the bit-bucket silently in GUI applications! */ #define STDIN_FILENO 0 #define STDOUT_FILENO 1 #define STDERR_FILENO 2 /* Returned by various functions on end of file condition or error. */ #define EOF (-1) /* * The maximum number of files that may be open at once. I have set this to * a conservative number. The actual value may be higher. */ #define FOPEN_MAX (20)
  • stdio.h (extrato): /* * Formatted Output */ _CRTIMP int __cdecl fprintf (FILE*, const char*, ...); _CRTIMP int __cdecl printf (const char*, ...); _CRTIMP int __cdecl sprintf (char*, const char*, ...); _CRTIMP int __cdecl _snprintf (char*, size_t, const char*, ...); _CRTIMP int __cdecl vfprintf (FILE*, const char*, __VALIST); _CRTIMP int __cdecl vprintf (const char*, __VALIST); _CRTIMP int __cdecl vsprintf (char*, const char*, __VALIST); _CRTIMP int __cdecl _vsnprintf (char*, size_t, const char*, __VALIST);
  • stdio.h (extrato): #ifndef __NO_ISOCEXT /* externs in libmingwex.a */ int __cdecl snprintf(char* s, size_t n, const char* format, ...); __CRT_INLINE int __cdecl vsnprintf (char* s, size_t n, const char* format, __VALIST arg) { return _vsnprintf ( s, n, format, arg); } int __cdecl vscanf (const char * __restrict__, __VALIST); int __cdecl vfscanf (FILE * __restrict__, const char * __restrict__, __VALIST); int __cdecl vsscanf (const char * __restrict__, const char * __restrict__, __VALIST); #endif
  • Cabeçalhos do ANSI C Cabeçalhos do ANSI C Macro para ajudar na detecção de erros lógicos e outros tipos de erros em <assert.h> versões de depuração de um programa. <complex.h> Conjunto de funções para manipular números complexos. Funções usadas para classificar caracteres pelo tipo ou para converter entre <ctype.h> caixa alta e baixa independentemente da codificação. <errno.h> Teste de códigos de erro reportados pelas funções de bibliotecas. <fenv.h> Controle de ponto flutuante. Constantes de propriedades específicas de implementação da biblioteca de ponto flutuante, como a menor diferença entre dois números de ponto <float.h> flutuante distintos (_EPSILON), a quantidade máxima de dígitos de acurácia (_DIG) e a faixa de números que pode ser representada (_MIN, _MAX). <inttypes.h> Conversão precisa entre tipos inteiros. <iso646.h> Programação na codificação de caracteres ISO 646. Constantes de propriedades específicas de implementação da biblioteca de <limits.h> tipos inteiros, como a faixa de números que pode ser representada (_MIN, _MAX). <locale.h> Constantes para setlocale() e assuntos relacionados. <math.h> Funções matemáticas comuns em computação. <setjmp.h> Macros setjmp e longjmp, para saídas não locais. <signal.h> Tratamento de sinais.
  • Cabeçalhos do ANSI C <stdarg.h> Acesso dos argumentos passados para funções com parâmetro variável. <stdbool.h> Definição do tipo de dado booleano. <stdint.h> Definição de tipos de dados inteiros. <stddef.h> Diversos tipos e macros úteis. <stdio.h> Manipulação de entrada/saída. Diversas operações, incluindo conversão, geração de números pseudo- <stdlib.h> aleatórios, alocação de memória, controle de processo, sinais, busca e ordenação. <string.h> Tratamento de cadeia de caracteres. <tgmath.h> Funções matemáticas. <time.h> Conversão de tipos de dado de data e horário. <wchar.h> Manipulação de caractere wide, usado para suportar diversas línguas. <wctype.h> Classificação de caracteres wide.
  • FUNÇÕES: Conjunto de comandos agrupados em um bloco que recebe um nome e através deste pode ser ativado.
  • Porque usar funções ? * Permitir o reaproveitamento de código já construído • (por você ou por outros programadores); * Evitar que um trecho de código que seja repetido várias vezes dentro de um mesmo programa; * Permitir a alteração de um trecho de código de uma forma mais rápida (alterar apenas dentro da função que se deseja); * Diminuir o tamanho dos blocos do programa, facilitando seu entendimento; * Facilita a leitura do programa-fonte; * Separar o programa em partes(blocos) que possam ser logicamente compreendidos de forma isolada.
  • Formato Geral de uma Função em C: tipo_da_funcao NomeDaFuncao (Lista_de_Parametros) { /* corpo da função */ } OBS: A Lista_de_Parametros, também é chamada de Lista_de_Argumentos, é opcional.
  • #include <conio.h> #include <dos.h> #include <stdio.h> void EsperaEnter() // Definição da função "EsperaEnter" { int tecla; printf("Pressione ENTERn"); do { tecla = getch(); if (tecla !=13) // Se não for ENTER { sound(700); // Ativa a emissão de um BEEP delay(10); // Mantém a emissão do som por 10 ms nosound(); // Para de emitir o som } } while(tecla != 13); // 13 é o codigo ASCII do ENTER } void main() { EsperaEnter(); // Chamada da função definida antes // ........... EsperaEnter(); // Chamada da função definida antes // ........... EsperaEnter(); // Chamada da função definida antes }
  • PALAVRAS RESERVADAS: A linguagem C possui um total de 32 palavras conforme definido pelo padrão ANSI, que são elas: •auto •double •int •struct •break •else •long •switch •case •enum •register •typedef •char •extern •return •union •const •float •short •unsigned •continue •for •signed •void •default •goto •sizeof •volatile •do •if •static •while
  • PALAVRAS RESERVADAS: É importante lembrar que todas as palavras reservadas são escritas em minúsculo e não podem ser utilizadas para outro propósito. Alguns compiladores incluem outras palavras reservadas como, asm, cdecl, far, fortran, huge, interrupt, near, pascal, typeof.