O documento resume as principais características da linguagem de programação C, incluindo sua estrutura, sintaxe, bibliotecas, funções e palavras reservadas. É definida como uma linguagem de propósito geral projetada para programação estruturada que possui facilidade de uso e geração de código eficiente.

1. Unidade Didática II
Estrutura de um Programa em C

2. 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.

3. 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.

4. 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).

5. A linguagem C

6. 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.

7. 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.

8. 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.

9. Editor (módulo fonte em C)
Pré-processador (novo fonte expandido)
Compilador (arquivo objeto)
Lincador (executável)

11. 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.

12. 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.

13. 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.

14. 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.

15. 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 */

17. 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.

18. 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.

19. 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.

20. As principais diretivas de compilação são:
#include
#define
#undef
#ifdef
#ifndef
#if
#else
#elif
#endif

21. 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.

22. 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.
*
*/

23. 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)

24. 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);

25. 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

26. 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.

27. 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.

28. FUNÇÕES:
Conjunto de comandos agrupados em um bloco
que recebe um nome e através deste pode ser
ativado.

29. 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.

30. 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.

31. #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
}

32. 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

33. 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.