Você está na página 1de 38

Introdução à Lingu

Exemplo de um Programa
// Exemplo de programa em C
// Isto é uma linha de comentário
void main()
{
int a; // declara a variável "a"
a = 3 + 2; // soma 3 com 2
}

 Um programa em C é composto por um


conjunto de Funções. A função pela qual o
programa começa a ser executado chama-
se main.
 Após cada cada comando em C deve-se colocar
um ; (ponto-e-vírgula).
 Um programa em C deve ser Identado para que
possa ser lido com mais facilidade.
Identificadores
São os nomes que podem ser dados para variáveis
e funções.
Para a escolha destes nomes é necessário seguir
alguams regras:
 Um identificador deve iniciar por uma letra ou
por um "_" (underscore);
 A partir do segundo caracter pode conter letras,
números e underscore;
 Deve-se usar nomes significativos dentro do
contexto do programa;
 C é uma linguagem case-sensitive, ou seja, faz
diferença entre nomes com letras maiúsculas e
nomes com letras minúsculas. Peso e peso
são diferentes;
 Costuma-se usar maiúsculas e minúsculas para
separar palavras: "PesoDoCarro";
 Deve ser diferente dos comandos da linguagem;
 Deve ter no máximo 31 caracteres (no caso do
TurboC);
 Pode conter números a partir do segundo
caracter;
 Exemplos:
Idade, Contador, PesoDoCarro,
Usuario_1, CorDaPagina, RaioDoCirculo

Variáveis
Uma variável é uma possição de memória que pode
ser identificada através de um nome.
Podem ter seu conteúdo alterado por um comando
de atribuição.
Após a atribuição mudam de valor.
int a,b, SomaGeral;
a = 3; // a recebe o valor 3
b = a * 2; // b recebe o dobro do valor de a
c = a + b + 2; // c recebe 11

Tipos de Variáveis
 Todas as variáveis em C tem um tipo;
 Cada tipo define os valores que a variável pode
armazenar;
 Cada tipo ocupa uma certa quantidade de
nemória.
Tipo Valores Válidos
char letras e símbolos: 'a', 'b', 'H', '^', '*','1','0'
int de -32767 até 32767 (apenas números inteiros)
float de -3.4 x 1038 até +3.4 x 10+38com até 6 dígitos de precisão
double de -1.7 x 10308 até +1.7 x 10+308com até 10 dígitos de precisão

Declaração de Variáveis
 Todas as variáveis tem que ser
declaradas antes de serem usadas;
 Não há uma inicialização implícita na
declaração
// Exemplo de programa em C

#include <stdio.h> // Arquivo de cabeçalho (header)


void main()
{
int contador; // declarações simples
float PrecoDoQuilo;
double TaxaDeCambio;
char LetraDigitada;
int IdadeManoel, IdadeJoao, IdadeMaria; // Pode colocar mais
de uma variável na
// na mesma linha
double TaxaDoDolar,
TaxaDoMarco,
TaxaDoPeso, // Também pode trocar de linha no
meio
TaxaDoFranco;
.......
}

Inicialização de Variáveis na Declaração


// Exemplo de programa em C

#include <stdio.h> // Arquivo de cabeçalho (header)


void main()
{
int NroDeHoras = 0; // declara e inicializa com Zero
float PrecoDoQuilo = 10.53; // declara e inicializa com
10.53
double TaxaDoDolar = 1.8,
TaxaDoMarco = 1.956,
TaxaDoPeso = 1.75,
TaxaDoFranco = 0.2;
.......
}
Constantes
Constantes são identificadores que não podem ter seus valores
alterados durante a execução do programa.

Para criar uma constante existe o comando #define que, em geral é


colocado no início do programa-fonte.

Exemplos

#define LARGURA_MAXIMA 50 // Não se coloca ponto-e-vírgula


após o valor
#define NRO_DE_DIAS_DA_SEMANA 7
#define NRO_DE_HORAS_DO_DIA 24
#define VALOR_DE_PI 3.1415
void main ()
{
int TotalDeHoras;

TotalDeHoras = 10 * NRO_DE_DIAS_DA_SEMANA * NRO_DE_HORAS_DO_DIA;


......
}

Strings
Uma String é uma sequência de caracteres entre
aspas duplas: "exemplo de uma string em C".
A função printf
A função printf exibe um ou mais dados na tela. Para tanto ele deve
receber pelo menos dois parâmetros, separados por vírgula:

 um string de formato que define, através de caracteres


especiais, os tipos dos dados a serem impressos e suas
posições na linha de impressão;
 um dado a ser impresso. Este dado pode ser qualquer um dos
dados visto anteriormente.

Por exemplo:

printf("%s","teste");

"%s" : é a string de formato


"teste" : é o dado a ser impresso.
A string de formato define quais os tipos dos dados a serem impressos. O
símbolo %s será substituído pelo dado que vem após a vírgula.
Os dados definem quais os valores a serem impressos.

Se for necessário, um string de formato pode definir que mais de um dado


será impresso. Para tanto, dentro da string de formato deve haver mais de
um %, um para cada dado a ser impresso.
Neste caso, os dados devem vir após a string de formato separados por
vírgulas.

Por exemplo:

printf("%s %s","teste1", "outra string");

Isto irá imprimir o string teste1 deixar 1 espaço em branco e imprimir ao


lado o string outra string, assim :

teste1 outra string

#include <stdio.h> // Necessário para usar a função printf


// A função printf exibe um ou mais dados na
tela
void main ()
{
printf("%s","Isto é uma string ....\n"); // note o '\n' no final da
string;
printf("%s","Outra string ....");
printf("%s","Terceira string\n");
//Depois de Executar o programa, tecle ALT-F5 para ver o resultado na
tela
}

Exercício

Experimente colocar um '\n' entre os %s na string de formato.

printf("%s\n%s","teste1", "outra string");

Inclusão de Texto na String de Formato


É possível incluir um texto dentro da string de formato. Este texto irá aparecer
exatamente como for digitado no programa-fonte.

O exemplo
printf("A aluna %s ficou
doente","Maria");
geraria
A aluna Maria ficou doente

como resultado.

Constantes do tipo String


#define UNIVERSIDADE "Pontifícia Universidade Católica do Rio Grande
do Sul"
// deve-se colocar entre aspas
#include <sdtio.h>
#include <conio.h> // necessário para as funções clrscr e getch
void main ()
{
clrscr(); // Limpa a tela
printf("%s", UNIVERSIDADE); // Imprime o nome representado pela
constante
getch(); // espera que o usuário pressione uma tecla
}

Impressão de Inteiros com "printf"


Para imprimir um inteiro com printf usa-se o símbolo %d

// Impressão de Variáveis Inteiras


#include <stdio.h>
#include <conio.h> // necessário para as funções clrscr e getch
void main ()
{
int Contador;
int NroDeFilhos;

clrscr(); // Limpa a tela

Contador = 10;
printf("Valor da Variável: %d\n", Contador); // No momento da
execução sinal %d vai
// ser substituído pelo
valor da
// variável Contador
NroDeFilhos = 3;
printf("Maria tem %d filhos", NroDeFilhos); // o inteiro pode
ficar no meio da string
getch(); // espera que o usuário pressione uma tecla
}

Impressão de Expressões aritméticas


// Impressão de Expressões aritméticas
#include <stdio.h>
#include <conio.h> // necessário para as funções clrscr e getch
void main ()
{
int NroDeAndares;
int AlturaPorAndar;

clrscr(); // Limpa a tela


NroDeAndares = 7;
AlturaPorAndar = 3;

printf("Altura Total do Prédio: %d metros",


NroDeAndares*AlturaPorAndar);
// No momento da execução sinal %d vai ser substituído
// pelo valor da multiplicação
getch(); // espera que o usuário pressione uma tecla
}

Impressão de Números reais


// Impressão de números reais
#include <stdio.h>
#include <conio.h> // necessário para as funções clrscr e getch
void main ()
{
float NotaDaP1, NotaDaP2;
float Media;

clrscr(); // Limpa a tela


NotaDaP1 = 6.6; // Atribuição do Valores das médias
NotaDaP2 = 8.2;

Media = (NotaDaP1 + NotaDaP2) / 2.0;

printf("Média Final : %f", Media);


// No momento da execução sinal %f vai ser substituído
// pelo valor da variável Media com SEIS casas decimais
// Média Final : 7.400000
getch(); // espera que o usuário pressione uma tecla
}

Formato de Impressão dos Números Reais


No exemplo acima o resultado da média (7.4) foi impresso com 6 casas
decimais (7.400000).

Isto sempre acontece quando se manda imprimir um float da forma como foi
feito no exemplo acima. Isto acontece pois o padrão da função printf é
completar o número com zeros à direita, até que fique com seis casas
decimais.

Para formatar de maneira diferente usar-se, junto com o %f uma especificação


de quantas casas decimais se deseja que o número tenha. Especifica-se
também o número total de caracteres do número a ser impresso.
Por exemplo: %6.3f especifica que se quer imprimir um float com 3 casas
decimais e com um tamanho total de 6 caracteres no total.

#include <stdio.h>
#include <conio.h>
void main()
{
float NotaDaP1, NotaDaP2;
float Media;

clrscr(); // Limpa a tela


NotaDaP1 = 6.6; // Atribuição do Valores das médias
NotaDaP2 = 8.2;

Media = (NotaDaP1 + NotaDaP2) / 2.0;

printf("Média Final : %6.3f", Media);


// No momento da execução sinal %6.3f vai ser substituído
// pelo valor da variável Media
// Média Final : 7.400
getch(); // espera que o usuário pressione uma tecla

Regras para impressão de um número real

 o número de casas decimais é sempre respeitado. Se for preciso, zeros


serão acrescetados à direita do número
 o tamanho total significa o número de caracteres do número incluíndo
o ponto decimal e um eventual sinal de
menos (-), se for o caso;
 Se a soma do número de caracteres da parte inteira, mais o ponto
decimal, mais a parte fracionária, mais um eventual sinal de
menos ainda for menor do que o tamanho total especificado no
formato, então, espaços em branco serão acrescentados à esquerda da
parte real do número.
 Se a soma do número de caracteres da parte inteira, mais o ponto
decimal, mais a parte fracionária, mais um eventual sinal de
menos for maior do que o tamanho total especificado no formato,
então, apenas o número de casas decimais é respeitado

Por exemplo:

#include <stdio.h>
#include <conio.h>
void main()
{
float Numero;
Numero = -2.5;
clrscr();
printf("1234567890\n");
printf("%7f\n", Numero);
printf("%7.0f\n", Numero);
printf("%7.3f\n", Numero);
printf("%8.3f\n", Numero);
printf("%9.3f\n", Numero);
printf("\n");
printf("%8.4f\n", Numero);
printf("%8.1f\n", Numero);
printf("%6.12f\n", Numero);

getch();
}

// Resultados
1234567890
-2.500000
-2
-2.500
-2.500
-2.500

-2.5000
-2.5
-2.500000000000

Alinhamento de números à DIREITA

Nos exemplos anteriores os números ficavam sempre alinhados a partir da


esquerda.
Experimente colocar um sinal de menos logo depois do sinal de % e veja o
que acontece.
printf("%-7.3f\n", Numero);

Variáveis do Tipo String


Uma variável capaz de arrmazenar uma string deve ser declarada informando-
se qual o número máximo de caracteres que ela poderá armazenar.
Exemplo:
char Nome[30]; // isto define que a variável poderá armazenar uma
// string de até 29 caracteres.

Ao trabalharmos com strings deve-se incluir o arquivo de


cabeçalho string.h

Atribuição com strings


As atribuições de valores a strings devem ser feitas através da
função strcpy

// Exemplo com strings


#include <stdio.h>
#include <conio.h>
#include <string.h> // arquivo de cabeçalho para trabalhar com
strings

void main()
{
char Nome[30]; // declara uma string que poderá armazenar até 29
caracteres !!
clsrscr();
strcpy(Nome, "Jose da Silva"); // atribui "Jose da Silva" para a
variável Nome
printf("O funcionário %s foi tranferido", Nome); // no lugar de %s
aparecerá o
// conteúdo da
variável Nome
getch();
}

Operadores Aritméticos
- sinal de menos (unário) Maior
precedência
(avaliado
antes)
*,/ multiplicação e divisão
% módulo (reto da divisão)
+,- soma e subtração Menor
precedência
(avaliado
depois)

Pode-se usar parênteses para alterar a precedência.

Exercício
Crie um progama que organize os dados em uma tabela conforme o exemplo a
seguir. Os dados das células em amarelo deve ser informados através de
atribuições dentro do programa.

Procure usar somente os %f para definir o formato e a posição dos dados.


Não tente preencher os espaços com brancos. Por exemplo, use
printf ("%10d, QuantidadeDeBananas);

ou invés de
printf(" %d", QuantidadeDeBananas);

Produto Preço Unitário Quantidade Preço Total


Banana R$ 2.50 2 R$ 5.00
Uva R$ 6.50 6 R$ 39.00
Pessego R$ 10.22 10 R$ 102.20
Sub-Total R$ 146.20
Imposto (5%) R$ 7.31
Total R$ 153.51

C (linguagem de programação)
Origem: Wikipédia, a enciclopédia livre.

Saltar para a navegaçãoSaltar para a pesquisa

Nota: Para outros significados, veja C (desambiguação).


C

Paradigma Programação estruturada


Programação imperativa
Programação procedural

Surgido em 1972

Última versão C11 (dezembro de 2011)

Criado por Dennis Ritchie

Estilo de Estática, Fraco


tipagem:

Compiladores Borland C, Clang, GNU GCC, MSVC, Turbo C,


Watcom C, Tiny C Compiler

Dialetos: ANSI C, C99, C11, ISO C, K&R C

Influenciada ALGOL 68, Assembly, B, BCPL, CPL, Fortran, PL/I


por

Influenciou AWK, BitC, C++, C♯, C


Shell, D, Euphoria, Go, Java, JavaScript, Limbo, Logic
Basic, Objective-C, Perl, PHP, Python

Licença: Dependente de implementação

Extensão do .c, .h[1]


arquivo:

C é uma linguagem de programação compilada de propósito


geral, estruturada, imperativa, procedural, padronizada pela ISO, criada em 1972, por Dennis
Ritchie, no AT&T Bell Labs, para desenvolver o sistema operacional Unix (que foi originalmente
escrito em Assembly).[2]
C é uma das linguagens de programação mais populares[3][4] e existem poucas arquiteturas para as
quais não existem compiladores para C. C tem influenciado muitas outras linguagens de
programação,[5] mais notavelmente C++, que originalmente começou como uma extensão para C.

Índice

 1História
o 1.1C K&R
o 1.2ANSI C e ISO C
o 1.3C99
o 1.4C11
 2Visão geral
o 2.1Tipos de dados
 3Relações com C++
 4Exemplos
o 4.1Programa Olá Mundo
o 4.2Matemática
o 4.3Estruturas de dados
 5Ferramentas de programação
 6Ver também
 7Referências
 8Ligações externas

História[editar | editar código-fonte]

Ken Thompson e Dennis Ritchie (da esquerda para direita), os criadores das linguagens B e C,
respectivamente.

O desenvolvimento inicial de C ocorreu no AT&T Bell Labs entre 1969 e 1973.[6] de acordo com
Ritchie, o período mais criativo ocorreu em 1972. A linguagem foi chamada "C", porque suas
características foram obtidas a partir de uma linguagem anteriormente chamado de "B", que de
acordo com a Ken Thompson era versão reduzida da linguagem de programação BCPL.[7]
A versão original PDP-11 do sistema Unix foi desenvolvido em assembly. Em 1973, com a adição
dos tipos struct , a linguagem C tornou-se poderosa o suficiente para que a maior parte
do kernel do Unix fosse reescrito em C. Este foi um dos primeiros núcleos de sistemas operacionais
implementados numa linguagem diferente da linguagem Assembly. Em 1977, foram feitas novas
mudanças por Ritchie e Stephen C. Johnson para facilitar a portabilidade do sistema operacional
Unix. O Portable C Compiler de Johnson serviu de base para várias implementações de C em novas
plataformas.[8]
C K&R[editar | editar código-fonte]
A linguagem C não teve um sucesso imediato após a sua criação e o seu uso ficou restrito a alguns
laboratórios,[9] mas em 1978 Brian Kernighan e Dennis Ritchie lançam o livro The C Programming
Language.[10] que serviu de tutorial e mudou a história da programação em C. De fato essa primeira
versão da linguagem é conhecida como "C Kernigham e Ritchie" ou apenas "C K&R".[11]
Esse livro, conhecido pelos programadores de C como "K&R", serviu durante muitos anos como
uma especificação informal da linguagem. A versão da linguagem C que ele descreve é usualmente
referida como "K&R C". A segunda edição do livro cobriu o padrão posterior, o ANSI C. K&R C
introduziu as seguintes características na linguagem:

 Biblioteca padrão de E/S


 Tipo de dados struct
 Tipo de dados long int
 Tipo de dados unsigned int
 O operador =+ foi alterado para += , e =- para -= (o analisador léxico do compilador fazia
confusão entre i =+ 10 e i = +10 . O mesmo acontecia com =- )
K&R C é frequentemente considerado a parte mais básica da linguagem, cujo suporte deve ser
assegurado por um compilador C. Durante muitos anos, mesmo após a introdução do padrão ANSI
C, K&R C foi considerado o "menor denominador comum", em que programadores de C se
apoiavam quando uma portabilidade máxima era desejada, já que nem todos os compiladores eram
actualizados o bastante para suportar o padrão ANSI C.
Nos anos que se seguiram à publicação do K&R C, algumas características "não-oficiais" foram
adicionadas à linguagem, suportadas por compiladores da AT&T e de outros vendedores. Estas
incluíam:

 Funções void e tipos de dados void *


 Funções que retornam tipos struct ou union
 Campos de nome struct num espaço de nome separado para cada tipo struct
 Atribuição a tipos de dados struct
 Qualificadores const para criar um objecto só de leitura
 Biblioteca padrão, que incorpora grande parte da funcionalidade implementada por vários
vendedores
 Enumerações
 Cálculos de ponto-flutuante em precisão simples (no K&R C, os cálculos intermediários eram
feitos sempre em double , porque era mais eficiente na máquina onde a primeira
implementação do C foi feita)
Esta página ou secção cita fontes confiáveis e independentes, mas que não cobrem todo o conteúdo, o que co
a verificabilidade (desde agosto de 2013). Por favor, insira mais referências no texto. Material sem fontes poderá ser
—Encontre fontes: Google (notícias, livros e acadêmico)

ANSI C e ISO C[editar | editar código-fonte]


Durante os finais da década de 1970, a linguagem C começou a substituir a linguagem BASIC como
a linguagem de programação de microcomputadores mais usada. Durante a década de 1980, foi
adaptada para uso no PC IBM, e a sua popularidade começou a aumentar significativamente. Ao
mesmo tempo, Bjarne Stroustrup, juntamente com outros nos laboratórios Bell, começou a trabalhar
num projecto onde se adicionavam extras para programação orientada por objectos à linguagem C. A
linguagem que eles produziram, chamada C++, é nos dias de hoje a linguagem de programação de
aplicações mais comum no sistema operativo Windows da companhia Microsoft. A linguagem C
permanece a mais popular no mundo Unix.
Em 1983, o instituto norte-americano de padrões (ANSI) formou um comité, X3J11, para estabelecer
uma especificação do padrão da linguagem C. Após um processo longo e árduo, o padrão foi
completo em 1989 e ratificado como ANSI X3.159-1989 "Programming Language C". Esta versão
da linguagem é frequentemente referida como ANSI C. Em 1990, o padrão ANSI C, após sofrer
umas modificações menores, foi adotado pela Organização Internacional para Padronização (ISO)
como ISO/IEC 9899:1990, também conhecido como C89 ou C90. Um dos objetivos do processo de
padronização ANSI C foi o de produzir um sobreconjunto do K&R C, incorporando muitas das
características não-oficiais subsequentemente introduzidas. Entretanto, muitos programas tinham
sido escritos e que não compilavam em certas plataformas, ou com um certo compilador, devido ao
uso de bibliotecas de funções não-padrão e ao fato de alguns compiladores não aderirem ao ANSI C.
C99[editar | editar código-fonte]
Após o processo da padronização ANSI, as especificações da linguagem C permaneceram
relativamente estáticas por algum tempo, enquanto a linguagem C++ continuou a evoluir. (em 1995,
a Normative Amendment 1 criou uma versão nova da linguagem C mas esta versão raramente é tida
em conta.) Contudo, o padrão foi submetido a uma revisão nos finais da década de 1990, levando à
publicação da norma ISO 9899:1999 em 1999. Este padrão é geralmente referido como "C99" e foi
adoptado como um padrão ANSI em março de 2000. As novas características do C99 incluem:

 Funções em linha
 Remoção de restrições sobre a localização da declaração de variáveis (como em C++)
 Adição de vários tipos de dados novos, incluindo o long long int (para minimizar
problemas na transição de 32-bits para 64-bits), um tipo de dados boolean explicito
(chamado _Bool) e um tipo complex que representa números complexos
 Vetores de dados de comprimento variável (o vetor pode ter um tamanho diferente a cada
execução de uma função, mas não cresce depois de criado)
 Suporte oficial para comentários de uma linha iniciados por // , emprestados da linguagem
C++
 Várias funções de biblioteca novas, tais como snprintf()
 Vários ficheiros-cabeçalho novos, tais como stdint.h
O interesse em suportar as características novas de C99 parece depender muito das entidades. Apesar
do GCC e vários outros compiladores suportarem grande parte das novas características do C99, os
compiladores mantidos pela Microsoft e pela Borland suportam pouquíssimos recursos do C99, e
estas duas companhias não parecem estar muito interessadas em adicionar tais funcionalidades,
ignorando por completo as normas internacionais. A Microsoft parece preferir dar mais ênfase ao
C++.[12]
C11[editar | editar código-fonte]
Em 2007, se iniciou o trabalho em antecipação de outra revisão do padrão de C, informalmente
chamada de C11 ou C1X. O comitê dos padrões de C adotou regras para limitar a inserção de novos
recursos que não tenham ainda sido testados por implementações existentes.[13]
Em dezembro de 2011 foi publicada a versão estável da especificação, como ISO/IEC 9899:2011.

Visão geral[editar | editar código-fonte]


C é uma linguagem imperativa e procedural para implementação de sistemas. Seus pontos de design
foram para ele ser compilado, fornecendo acesso irrestrito a memória e baixos requerimentos do
hardware. Também foi desenvolvido para ser uma linguagem de alto nível, para maior
reaproveitamento do código. C foi útil para muitas aplicações que foram codificadas originalmente
em Assembly.
Essa propriedade não foi acidental; a linguagem C foi criada com o objectivo principal em mente:
facilitar a criação de programas extensos com menos erros recorrendo ao paradigma da programação
procedural mas sobrecarregando menos o autor do compilador, cujo trabalho complica-se ao ter de
realizar as características complexas da linguagem. Para este fim, a linguagem C possui as seguintes
características:

 Uma linguagem extremamente simples, com funcionalidades não-essenciais, tais como


funções matemáticas ou manuseamento de ficheiros (arquivos), fornecida por um conjunto
de bibliotecas de rotinas padronizada
 A focalização no paradigma de programação procedural
 Um sistema de tipos simples que evita várias operações que não fazem sentido
 Uso de uma linguagem de pré-processamento, o pré-processador de C, para tarefas tais como
a definição de macros e a inclusão de múltiplos ficheiros de código fonte
 Ponteiros dão maior flexibilidade à linguagem
 Acesso de baixo nível, através de inclusões de código Assembly no meio do programa C
 Parâmetros que são sempre passados por valor para as funções e nunca por referência (É
possível simular a passagem por referência com o uso de ponteiros)
 Definição do alcance lexical de variáveis
 Estruturas de variáveis, (structs), que permitem que dados relacionados sejam combinados e
manipulados como um todo
Algumas características úteis, que faltam em C, podem ser encontradas em outras linguagens, que
incluem:

 Segurança de tipo
 Coletor de lixo (mais comum em linguagens interpretadas)
 Vetores que crescem automaticamente
 Classes ou objetos com comportamento (ver Orientação a objetos)
 Clausuras
 Funções aninhadas
 Sobrecarga de operadores
 Meta-programação
 Apoio nativo de multithreading e comunicação por rede
Apesar da lista de características úteis que C possui não ser longa, isso não tem sido um
impedimento à sua aceitação, pois isso permite que novos compiladores de C sejam escritos
rapidamente para novas plataformas, e também permite que o programador permaneça sempre em
controle do que o programa está a fazer. Isto é o que por várias vezes permite o código de C correr
de uma forma mais eficiente que muitas outras linguagens. Tipicamente, só código de Assembly
"afinado à mão" é que corre mais rapidamente, pois possui um controle completo da máquina, mas
avanços na área de compiladores juntamente com uma nova complexidade nos processadores
modernos permitiram que a diferença tenha sido rapidamente eliminada. Uma consequência da
aceitação geral da linguagem C é que frequentemente os compiladores, bibliotecas e
até interpretadores de outras linguagens sejam implementados em C.
C tem como ponto forte a sua eficiência, e é a linguagem de programação preferida para o
desenvolvimento de sistemas e softwares de base, apesar de também ser usada para
desenvolver programas de computador. É também muito usada no ensino de ciência da computação,
mesmo não tendo sido projetada para estudantes e apresentando algumas dificuldades no seu uso.
Outra característica importante de C é o seu código resultante em Assembly ter funcionamento
idêntico ao código fonte, que permite que um projetista seja capaz de fazer algumas previsões de
como o software irá se comportar ao ser executado.
O ponto negativo de C está na possibilidade do programador cometer erros graças a liberdade que a
linguagem oferece. Por exemplo é possível acessar área de memória que não pertence a um vetor ao
acessar um índice maior que seu tamanho, possibilitando que ocorra um buffer overflow. Isto
acontece em C porque o dever de controlar a memória está nas mãos do programador. O motivo de
C dar total controle para o programador é porque a linguagem foi projetada para programar o sistema
operacional UNIX, onde havia a necessidade desse controle sobre a forma como o sistema iria
funcionar. [2]
Tipos de dados[editar | editar código-fonte]
C tem um sistema de tipos semelhante ao de alguns descendentes da linguagem ALGOL, tais
como Pascal. Possui tipos para números inteiros de vários tamanhos com e sem sinal, números de
ponto flutuante, caracteres e estruturas ( struct s). C usa extensivamente ponteiros, um tipo muito
simples de referência que guarda o endereço de memória da variável. O ponteiro pode
ser desreferenciado, uma operação que busca o objeto que se encontra na morada da memória que o
ponteiro possui, morada essa que pode ser manipulada através de aritmética de ponteiros. Durante
o tempo de execução, o ponteiro é simplesmente uma morada de máquina tais como aquelas
manipuladas em Assembly, mas em tempo de compilação possui um tipo complexo que indica o tipo
do objecto para onde ele aponta, permitindo que se verifique o tipo de expressões, incluindo
ponteiros. O tipo "string" (cadeia ou linha de texto) de C é simplesmente um ponteiro para um vetor
de caracteres e alocação dinâmica de memória, descrita abaixo, é efetuada através de ponteiros.
Os ponteiros em C possuem um valor reservado especial, NULL , que indica que não estão a apontar
para uma morada. O uso desse valor como morada é muito útil na construção de várias estruturas de
dados, mas causa comportamento não-definido (possivelmente uma falha de sistema) ao ser
desreferenciado. Um ponteiro que possui o valor NULL é chamado ponteiro nulo. Os ponteiros são
declarados (e desreferenciados) com um * (asterisco), portanto o tipo int* denota um ponteiro para
número(s) inteiro(s). A linguagem C também fornece um tipo especial de ponteiros, o void*, que se
traduz num ponteiro que aponta para um objeto de tipo desconhecido.
A linguagem C também tem apoio em nível de linguagem para vetores estáticos (de dimensão fixa)
de tipos. As disposições de tipos podem parecer ter mais que uma dimensão apesar de serem
tecnicamente disposições de disposições de tipos. Em memória, tais estruturas são posicionadas com
as linhas uma depois da outra (a alternativa seria armazenar os dados em colunas, usado em outras
linguagens). O acesso a disposições de tipos é feito através de ponteiros e aritmética de ponteiros; o
nome da disposição é tratado como se fosse um ponteiro que aponta para o início da disposição. Em
certas aplicações não é razoável usarem-se disposições de tipos de dimensão fixa e por isso a
alocação dinâmica de memória pode ser usada para criar disposições de tipos de dimensão variável.
Como a linguagem C é regularmente usada em programação de baixo-nível de sistemas, há casos em
que é necessário tratar um número inteiro como sendo um ponteiro, um número de ponto flutuante
como sendo um número inteiro ou um tipo de ponteiro como sendo outro. Para estes casos, a
linguagem C fornece a capacidade de "moldagem" (também denominado "conversão de tipo" ou
"casting"), uma operação que, caso seja possível, força a conversão de um objeto de um tipo para
outro. Apesar de ser por vezes necessário, o uso de conversões de tipo sacrifica alguma segurança
oferecida pelo sistema de tipos.
int
O tipo de dado int (inteiro) serve para armazenar valores numéricos inteiros. Existem vários tipos de
inteiros, cada um de um tamanho diferente (dependendo do sistema operacional e/ou arquitetura do
processador):

 int , pode possuir 16 bits, 32 bits ou 64 bits


 short int , deve possuir tamanho de no mínimo 16 bits e não pode ser maior que int
 long int , deve possuir tamanho mínimo de 32 bits
 long long int , deve possuir tamanho mínimo de 64 bits

Todos estes tipos de inteiros podem ainda ser declarados precedidos da cláusula unsigned, o que faz
com que só suporte números positivos. Isto faz com que, com o mesmo tamanho, uma variável
suporte mais números positivos do que um signed (todos os inteiros são signed por omissão).
char
O tipo char ocupa 1 byte, e serve para armazenar caracteres ou inteiros. Isso significa que o
programa reserva um espaço de 8 bits na memória RAM ou em registradores do processador para
armazenar um valor (char de tamanho maior que 8 bits é permitido pela linguagem, mas os casos
são raros). Com vetores do tipo char é possível criar cadeias de caracteres (strings).
float
O tipo de dado float serve para armazenar números de ponto flutuante, ou seja, com casas decimais.
O padrão mais utilizado nos últimos 10 anos é o IEEE 754-1985.
double
O tipo de dado double serve para armazenar números de ponto flutuante de dupla precisão,
normalmente tem o dobro do tamanho do float e portanto o dobro da capacidade. O padrão mais
adotado também é o IEEE 754-1985.
struct
Em C podem ser usadas estruturas (chamados de registos em outras linguagens de programação). As
estruturas são grupos de variáveis organizadas arbitráriamente pelo programador. Uma estrutura
pode criar um novo tipo de variável caso typedef seja usado em sua declaração.

Relações com C++[editar | editar código-fonte]


A linguagem de programação C++ foi originalmente derivada do C para suportar
programação orientada a objetos. À medida que as linguagens C e C++ foram evoluindo
independentemente, a divisão entre as duas veio a aumentar. O padrão C99 criou um número de
características que entram em conflito. Hoje, as principais diferenças entre as duas linguagens são:

 inline - em C++, funções em linha encontram-se no espaço global enquanto que em C


encontram-se no espaço local. Por outras palavras, isso significa que, em C++, qualquer
definição de qualquer função em linha (sem ser a respeito da sobrecarga de funções de C++)
tem de estar em conformidade com a "regra de uma definição" da linguagem C++. Mas em C, a
mesma função em linha pode ser definida de maneira diferente em diferentes arquivos (ou
ficheiros)
 A palavra-chave bool , igual à usada em C++, em C99 necessita que se inclua o ficheiro-
cabeçalho <stdbool.h> (_Bool está sempre disponível). Padrões anteriores de C não
definiam um tipo booleano e vários (e incompatíveis) métodos foram usados para simular um
tipo booleano
Algumas características originalmente desenvolvidas em C++ também apareceram em C. Entre elas
encontram-se:

 protótipos de função (com declaração de tipos de parâmetros) e remoção do "int" implícito


 comentários de linha, indicados por // ; comentários de linha terminam com um carácter de
nova-linha
 a palavra-chave inline
 tipagem mais forte

Exemplos[editar | editar código-fonte]


Programa Olá Mundo[editar | editar código-fonte]
Ver artigo principal: Programa Olá Mundo

A seguinte aplicação foi publicada na primeira edição de C de K&R, e tornou-se no programa de


introdução padrão da maior parte dos livros sobre C. O programa envia o texto "Olá, Mundo!" para
a saída padrão, que é normalmente o console, mas que também pode ser um ficheiro (ou arquivo),
um outro dispositivo qualquer, ou até mesmo um bit bucket, dependendo de como a saída-padrão é
mapeada na altura em que o programa é executado.

int main(void)
{
puts("Olá, Mundo!");
}

Apesar do programa acima correr corretamente, atualmente origina algumas mensagens de aviso
quando compilado como C ANSI. Essas mensagens podem ser eliminadas efectuando umas
pequenas alterações no programa original:

# include <stdio.h> /* Pacotes com funções de entrada e saída */


int main(void)
{
puts("Olá, Mundo!");
return 0; /* Retorna 0, pois `main` retorna um `int` */
}
/* Nova linha após fechar a chave principal */

A primeira linha do programa é uma diretiva de pré-processamento #include , que causa com que
o pré-processador substitua aquela linha pela totalidade do conteúdo do arquivo qual diretiva se
refere. Neste caso o arquivo padrão stdio.h (que contém protótipos de funções para trabalho com
entrada e saída) irá substituir a linha. Os caracteres < e > indicam que o arquivo stdio.h encontra-se
no local em que, quando da configuração do compilador, se definiu como padrão para localização
dos ficheiros de inclusão (header files, geralmente com a extensão .h).
A linha (não-vazia) seguinte indica que uma função denominada main será definida. A
função main tem um significado especial nos programas em C, pois é a função que é inicialmente
executada (em inglês, entry point). Os caracteres { e } delimitam a extensão da função. O
termo int define a função main como sendo uma função que retorna um número inteiro. O
termo void indica que a função não aceita parâmetros. A função main, normalmente aceita
parâmetros, que são passado pela linha de comando. Os compiladores e sistemas operacionais atuais
reconhecem as seguintes declarações de main:

int main(void);
int main(int argc, char *argv[]);
int main(int argc, char **argv);

A linha seguinte "chama", ou executa uma função chamada puts ; o arquivo incluído, stdio.h ,
contém a informação que descreve a forma como a função puts deve ser chamada. Nesta chamada,
é passado à função puts um único argumento, a linha de texto constante "Olá, Mundo!". A
função puts retorna um valor, um int , mas como não é usado, é descartado pelo compilador. O
comando return retorna o valor 0 para o sistema, que é interpretado pelo mesmo como que a
função main() foi executada e encerrada com sucesso (sem erros). Por fim, o caracter } indica o fim
da função main . Note-se que texto rodeado por /* e */ (comentários de texto) é ignorado pelo
compilador. Os compiladores que obedecem à norma C99 também aceitam como comentários as
linhas de texto que são precedidos por // .

Matemática[editar | editar código-fonte]


O seguinte código realiza seis operações
matemáticas, adição, subtração, multiplicação, divisão, exponenciação e radiciação, e em seguida
envia os seus respectivos resultados para a saída padrão (normalmente o console).

# include <math.h> // necessária para pow() e sqrt()


# include <stdio.h> // necessária para printf() e getchar()

int main()
{
int a = 2, b = 3;

printf("%d + %d = %d\n", a, b, a + b);


printf("%d - %d = %d\n", a, b, a - b);
printf("%d x %d = %d\n", a, b, a * b);
printf("%d / %d = %0.1f\n", a, b, (float) a / b); // resultado
fracionário
printf("%d elevado a %d = %0.1f\n", a, b, pow(a, b)); // pow(base,
expoente)
printf("raiz quadrada de %d = %0.1f\n", a, sqrt(a));

getchar(); //O uso dessa função é necessária apenas nos sistemas


Windows, para manter o terminal (Prompt de comando) aberto
return 0;
}

Estruturas de dados[editar | editar código-fonte]


No exemplo seguinte, é criada uma estrutura composta por 3 elementos de tipos diferentes. Após ser
declarada uma variável "x" do tipo struct "y", onde "y" é o nome da estrutura, para se acessar os
elementos usa-se a seguinte sintaxe: x.elemento .

# include <stdio.h>

struct Pessoa
{
char nome[64]; // vetor de 64 chars para o nome
unsigned short int idade;
char rg[13];
};

int main()
{
struct Pessoa exemplo = {"Fulano", 16, "00.000.000-00"}; //
declaração da variável "exemplo"

printf("Nome: %s\n", exemplo.nome);


printf("Idade: %hu\n", exemplo.idade);
printf("RG: %s\n", exemplo.rg);

getchar(); // desnecessário, mas comumente utilizado em ambientes


windows para "segurar" o terminal aberto
return 0;
}
Ou, equivalente:

# include <stdio.h>

typedef struct Pessoa


{
char nome[64]; // vetor de 64 chars para o nome
unsigned short int idade;
char rg[13];
} Pessoa;

int main()
{
Pessoa exemplo = {"Filipe", 16, "00.000.000-00"}; // declaração da
variável "exemplo"

printf("Nome: %s\n", exemplo.nome);


printf("Idade: %hu\n", exemplo.idade);
printf("RG: %s\n", exemplo.rg);

getchar();
return 0;
}

Ferramentas de programação[editar | editar código-fonte]


 Bloodshed Dev-C++
 IDE (Ambiente de desenvolvimento integrado), como Code::Blocks, NetBeans e JetBrains CLion
 GNU Compiler Collection
 Automação de compilação, como make

Ver também[editar | editar código-fonte]


Outros projetos Wikimedia também contêm
material sobre este tema:

Livros e manuais no Wikilivros

 C++
 Linguagem compilada
 Linguagem de programação
 Linguagem de programação de alto nível
 Lista de linguagens de programação
 Unix
 Compilador

Referências
1. Ir para cima↑ «Overall Options - Using the GNU Compiler Collection (GCC)». gcc.gnu.org (em inglês).
Consultado em 13 de dezembro de 2017.
2. ↑ Ir para:a b «History of the C Programming Language» (em inglês). livinginternet.com. Consultado em
23 de maio de 2010.
3. Ir para cima↑ «Programming Language Popularity» (em inglês). langpop.com. Consultado em 23 de
maio de 2010.
4. Ir para cima↑ «TIOBE Programming Community Index» (em inglês). tiobe.com. Consultado em 23 de
maio de 2010.
5. Ir para cima↑ «C – The Influence Factor of Many Popular Programming Languages» (em inglês).
cprogramminglanguage.com. Consultado em 23 de maio de 2010.
6. Ir para cima↑ Ritchie, Dennis M. (janeiro de 1993). «The Development of the C Language».
Consultado em 1 de janeiro de 2008.. The scheme of type composition adopted by C owes
considerable debt to Algol 68, although it did not, perhaps, emerge in a form that Algol's adherents
would approve of.
7. Ir para cima↑ A Brief History of C
8. Ir para cima↑ Johnson, S. C.; Ritchie, D. M. (1978). «Portability of C Programs and the UNIX
System» (PDF). Bell System Tech. J. 57 (6): 2021–2048. Consultado em 16 de dezembro de 2012.
9. Ir para cima↑ «Entrevista com Dennis Ritchie, Bjarne Stroustrup e James Gosling» (em (em inglês)).
Java Report e C++ Report. Julho de 2000. Consultado em 3 de junho de 2015.
10. Ir para cima↑ Kernighan, Brian W.; Ritchie, Dennis M (1978). The C Programming Language(em
inglês). Upper Saddle River, New Jersey: Prentice hall. 228 páginas. ISBN 0-13-110163-3
11. Ir para cima↑ Rosangle Hickson. Aprenda a programa em C, C++ e C# 2a ed. [S.l.]: Campus.
p. 3. ISBN 978-85-352-1479-6
12. Ir para cima↑ «Microsoft dá mais ênfase ao C++» (em inglês). connect.microsoft.com. Consultado
em 23 de maio de 2010.
13. Ir para cima↑ «Grupo de trabalho do ISO C» (em inglês). open-std.org. Consultado em 23 de maio
de 2010.

Ligações externas[editar | editar código-fonte]


 C Progressivo (em português)
 [[1] Aprendendo a programar -- Programando na Linguagem C -- Jaime Evaristo, Universidade
Federal de Alagoas] (em português)
 Página oficial do ISO C Working Group (em inglês)
 C no DMOZ
[Expandir]

v•e

Linguagens de programação

[Expandir]

v•e

Lista de Normas da Comissão Eletrotécnica Internacional


Categorias:
 Linguagem de programação C
 Linguagens de programação procedurais
Menu de navegação
 Não autenticado

 Discussão

 Contribuições

 Criar uma conta

 Entrar
 Artigo
 Discussão
 Ler
 Editar
 Editar código-fonte
 Ver histórico
Busca
Ir

 Página principal
 Conteúdo destacado
 Eventos atuais
 Esplanada
 Página aleatória
 Portais
 Informar um erro
 Loja da Wikipédia
Colaboração
 Boas-vindas
 Ajuda
 Página de testes
 Portal comunitário
 Mudanças recentes
 Manutenção
 Criar página
 Páginas novas
 Contato
 Donativos
Imprimir/exportar
 Criar um livro
 Descarregar como PDF
 Versão para impressão
Noutros projetos
 Wikimedia Commons
 Wikilivros
Ferramentas
 Páginas afluentes
 Alterações relacionadas
 Carregar ficheiro
 Páginas especiais
 Hiperligação permanente
 Informações da página
 Elemento Wikidata
 Citar esta página
Noutras línguas
 ‫العربية‬
 English
 Español
 हिन्दी
 Bahasa Indonesia
 Latina
 Русский
 ‫اردو‬
 中文
99 outras
Editar hiperligações

 Esta página foi editada pela última vez às 10h54min de 20 de julho de 2018.
 Este texto é disponibilizado nos termos da licença Atribuição-CompartilhaIgual 3.0 Não Adaptada (CC BY-SA
3.0) da Creative Commons; pode estar sujeito a condições adicionais. Para mais detalhes, consulte
as condições de utilização.

 Política de privacidade

 Sobre a Wikipédia

 Avisos gerais

 Programadores

 Declaração sobre ''cookies''

 Versão móvel

Programação estruturada
Origem: Wikipédia, a enciclopédia livre.

Saltar para a navegaçãoSaltar para a pesquisa

A programação estruturada (PE) é um paradigma de programação, uma forma de programação de


computadores, com ênfase no uso de subrotinas, laços de repetição, condicionais e estruturas em
bloco.[1] Este paradigma surgiu ao final de 1950 junto às linguagens ALGOL 58 e ALGOL 60,[2] foi
impulsionado pelas vantagens práticas que o paradigma oferece, e também pelo 'teorema do
programa estruturado (en)' (de 1966, também chamado de teorema de Böhm-Jacopini) e a carta
aberta de Dijkstra 'Go To Statement Considered Harmful' (de 1968). De fato, muitas linguagens não
possuem GOTOs para desincentivar a programação não-estruturada (nota: Donald Knuth advocou
o GOTO em algumas circunstâncias[3]; mesmo depois do estabelecimento da programação
estruturada, parece que ainda não concorda com a abolição do GOTO, mas falta referência na
Wikipédia em inglês).
A PE foi o paradigma dominante na escrita de software até a programação orientada a objetos
(POO). Enquanto a PE fia-se em estruturas de controle de alto nível (em oposição ao uso
de GOTOs), concepções top-down e refinamento por passos, a POO se baseia no conceito de objetos
que possuem atributos (dados) e métodos (procedimentos). Apesar de ter sido sucedida pela POO, a
PE ainda é muito influente pois grande parte das pessoas ainda aprende programação através dela.
Para a resolução de problemas simples e diretos, a programação estruturada é bastante eficiente
(talvez mais eficiente que a POO). Além disso, por exigir formas de pensar relativamente
complexas, a POO até hoje ainda não é bem compreendida ou usada pela maioria.
Diversas linguagens relevantes hoje (e.g. Cobol, PHP, Perl e Go) ainda utilizam o paradigma
estruturado, embora possuam suporte para a orientação ao objeto e para outros paradigmas de
programação.

Índice

 1Elementos básicos da teoria


o 1.1Estruturas de controle
o 1.2Refinamento por passos
o 1.3Desvios
 2Conceito-chave: GOTO
 3Críticas usuais à PE
 4PE vs POO
 5Tópicos avançados
 6Referências

Elementos básicos da teoria[editar | editar código-fonte]


Estruturas de controle[editar | editar código-fonte]
Ver artigo principal: Estrutura de controle

Na PE, os programas são vistos como compostos das seguintes 'estruturas de controle' (ECs) [4]:

 Sequência: de instruções ou sub-rotinas executadas em sequência ( a=4; b=4*5 )


 Seleção/condicional: instruções são executadas ou não conforme o estado do programa (if,
else, elif/elseif, endif)
 iteração/repetição: instruções são executados até que o programa atinja um determinado
estado (for, while, repeat, do..until)
 recursão: instruções executadas com chamadas auto-referenciadas até que certas condições
sejam satisfeitas. Exemplo:

def fatorial(x):
if x > 1:
return x*fatorial(x-1)
return x

Há a utilização de 'sub-rotinas' em que as ECs são agrupadas e utilizadas através de um única


instrução (são as funções, métodos, subprogramas, procedimentos). Blocos permitem que uma
sequência de instruções seja tratada como uma única instrução.
Refinamento por passos[editar | editar código-fonte]
Uma ideia central na PE é o refinamento por passos, em que o programa é desenvolvido de maneira
top-down, por exemplo:

1. comece com o programa principal


 use as ECs de iteração e seleção
 escreva as chamadas para as rotinas (r1, r2, etc) quando necessário. Diz-se 'postule
r1, r2'.

1. Implemente r1, r2, ..., com chamadas para outras rotinas conforme conveniente.
2. Continue implementando as rotinas até que não sejam necessários procedimentos
adicionais.
Na prática, é usual iniciar a programação não exatamente do topo, até porque é comum que hajam
vários topos[5], mas isso depende da complexidade e modularidade do software.
Desvios[editar | editar código-fonte]
Dentre os desvios mais comuns da programação estruturada, há múltiplos pontos:

 De saída:
 terminação antecipada: return em uma função, break or continue em um laço de
interação, ou um exit em algum programa. Na programação estruturada, a rigor, há um só
ponto de saída da rotina sendo executada.
 Manejo de exceção: clausulas como (try.. except) do Python ou (try.. catch) do C++,
também implicam em múltiplos pontos de saída da rotina.
 De entrada: útil e.g. para geradores, streaming, máquinas de estado.

Conceito-chave: GOTO[editar | editar código-fonte]


Ver artigo principal: goto (programação)

Seja um programa uma sequência de instruções a serem seguidas (e.g. por um computador).
Considere um ponteiro que indica a instrução a ser executada na próxima oportunidade. Um GOTO
é um reposicionamento arbitrário deste ponteiro. Embora seja um comando poderoso, o uso de
GOTOs é considerado, em geral, má prática, havendo quem o defenda em algumas situações.[3]
Na programação imperativa, que possui ênfase na modificação de valores em endereços de memória
(i.e. instruções de atribuição), o uso de GOTOs é abundante. Em muitos contextos, pode-se assumir
que 'programação estruturada' é sinônimo de programação sem GOTO (sem pulos, sem
redirecionamentos arbitrários do ponteiro da sequência de instruções em execução). Estes foram os
dois primeiros paradigmas dominantes na programação de computadores. A imperativa desde o
início da programação até os anos 1970. A estruturada até o final década de 1990, e então deu lugar
à POO.

Críticas usuais à PE[editar | editar código-fonte]


Dentre as críticas à PE, constam[4]:
 PE é orientada para a resolução de um problema em particular.
 Um escopo mais amplo é muitas vezes conveniente.
 PE é realizada pela decomposição gradual da funcionalidade.
 As estruturas advindas de funcionalidade/ação/controle não são as partes mais estáveis
de um programa.
 Foco em estruturas de dados ao invés de estruturas de controle é uma alternativa.
 Sistemas reais não possuem um único topo.[5]
 Pode ser apropriado considerar alternativas à abordagem top-down.
Veja também a POO, paradigma que foi estabelecido depois de décadas de PE.

PE vs POO[editar | editar código-fonte]


A PE não é errada nem a POO certa. A POO tende a dar melhores resultados em programas maiores
e para reutilização dos programas (suas partes ou sub-rotinas). Como explicitado ao longo deste
artigo e do artigo sobre POO, ambos os paradigmas possuem vantagens e desvantagens. A melhor
prática parece ser evitar extremismo (i.e. moldes rígidos): há casos em que é melhor priorizar a POO
ou a PE, e mesmo quando uma estratégia é evidentemente melhor, o purismo tende a gerar software
menos bem escrito ao custo de mais trabalho.

Tópicos avançados[editar | editar código-fonte]


 Diagrama Nassi-Shneiderman: uma representação gráfica (structograma) para PE,
desenvolvida em 1972.
 Carta de estrutura (structure chart): um diagrama usado na PE para organizar os módulos em
árvore.

Referências
1. Ir para cima↑ «Programação estruturada». Faculdade de Engenharia Elétrica e de Computação -
UNICAMP. Consultado em 22 de novembro de 2016.
2. Ir para cima↑ Clark, Leslie B. Wilson, Robert G.; Robert, Clark (2000). Comparative programming
languages 3rd ed. Harlow, England: Addison-Wesley. p. 20. ISBN 9780201710120. Consultado em
25 de novembro de 2015.
3. ↑ Ir para:a b Knuth, Donald E. (1 de dezembro de 1974). «Structured Programming with go to
Statements». ACM Computing Surveys (CSUR). 6 (4): 261–301. ISSN 0360-
0300. doi:10.1145/356635.356640
4. ↑ Ir para:a b http://people.cs.aau.dk/~normark/oop-csharp/html/notes/theme-index.html
5. ↑ Ir para:a b Bertrand Meyer (2009). Touch of Class: Learning to Program Well with Objects and
Contracts. [S.l.]: Springer Science & Business Media. ISBN 978-3-540-92144-8

Este artigo sobre software é um esboço. Você pode ajudar a Wikipédia expandindo-o.

Categoria:
 Paradigmas de programação
Menu de navegação
 Não autenticado

 Discussão

 Contribuições

 Criar uma conta


 Entrar
 Artigo
 Discussão
 Ler
 Editar
 Editar código-fonte
 Ver histórico
Busca
Ir

 Página principal
 Conteúdo destacado
 Eventos atuais
 Esplanada
 Página aleatória
 Portais
 Informar um erro
 Loja da Wikipédia
Colaboração
 Boas-vindas
 Ajuda
 Página de testes
 Portal comunitário
 Mudanças recentes
 Manutenção
 Criar página
 Páginas novas
 Contato
 Donativos
Imprimir/exportar
 Criar um livro
 Descarregar como PDF
 Versão para impressão
Ferramentas
 Páginas afluentes
 Alterações relacionadas
 Carregar ficheiro
 Páginas especiais
 Hiperligação permanente
 Informações da página
 Elemento Wikidata
 Citar esta página
Noutras línguas
 ‫العربية‬
 Deutsch
 English
 Español
 Français
 Bahasa Indonesia
 Bahasa Melayu
 Русский
 中文
29 outras
Editar hiperligações

 Esta página foi editada pela última vez às 20h56min de 6 de julho de 2018.
 Este texto é disponibilizado nos termos da licença Atribuição-CompartilhaIgual 3.0 Não Adaptada (CC BY-SA
3.0) da Creative Commons; pode estar sujeito a condições adicionais. Para mais detalhes, consulte
as condições de utilização.

 Política de privacidade

 Sobre a Wikipédia

 Avisos gerais

 Programadores

 Declaração sobre ''cookies''

 Versão móvel
Leia o texto completo de nosso comunicado.

Programação imperativa
Origem: Wikipédia, a enciclopédia livre.

Saltar para a navegaçãoSaltar para a pesquisa

Esta página ou seção precisa ser wikificada (desde abril de 2015).


Por favor ajude a formatar esta página de acordo com as diretrizes estabelecidas.

Esta página ou secção não cita fontes confiáveis e independentes, o que compromete sua credibilidade (desde j
favor, adicione referências e insira-as corretamente no texto ou no rodapé. Conteúdo sem fontes poderá ser r
—Encontre fontes: Google (notícias, livros e acadêmico)

John von Neumann

Neumann, à época de Los Alamos (c. 1943-1945), primeiro


laboratório de armas nucleares dos Estados Unidos

Conhecido(a) Álgebra abeliana de von


por Neumann, Álgebra de von
Neumann, Arquitetura de von
Neumann, Universo de von
Neumann

Nascimento 28 de dezembro de 1903


Budapeste

Morte 8 de fevereiro de 1957 (53 anos)


Washington, D.C.

Nacionalidade Húngaro
Estadunidense
Prêmios Prêmio Bôcher (1938), Prêmio
Enrico Fermi (1956)

Orientador(es) Lipót Fejér

Orientado(s) Israel Halperin, Donald Bruce


Gillies, John Patterson Mayberry

Campo(s) Matemática

Tese 1926

Na Ciência da Computação, programação imperativa é um paradigma de programação que


descreve a computação como ações, enunciados ou comandos que mudam o estado (variáveis) de
um programa. Muito parecido com o comportamento imperativo das linguagens naturais que
expressam ordens, programas imperativos são uma sequência de comandos para o computador
executar. O nome do paradigma, Imperativo, está ligado ao tempo verbal imperativo, onde o
programador diz ao computador: faça isso, depois isso, depois aquilo... Este paradigma de
programação se destaca pela simplicidade, uma vez que todo ser humano, ao se programar, o faz
imperativamente, baseado na ideia de ações e estados, quase como um programa de computador.

Máquina de Turing

O fundamento da programação imperativa é o conceito de Máquina de Turing, que nada mais é que
uma abstração matemática que corresponde ao conjunto de funções computáveis.
A Máquina de Turing foi aprimorada por John Von Neumann a uma arquitetura de computadores
que fundamenta os computadores construídos até hoje. Isso explica, em parte, o sucesso das
linguagens que seguem esse paradigma em relação às demais. Nesta arquitetura( usada hoje nos
microcomputadores comercializados), tanto os dados como os programas são armazenados na
mesma memória, e a CPU que processa as instruções, é separada da memória. Dessa forma, os dados
e instruções devem ser transportados da memória para a CPU e os resultados das operações
realizadas na CPU devem ser devolvidos para a memória.
As linguagens imperativas estruturadas sofrem no entanto de uma falta de flexibilidade dadas o
caráter sequencial das instruções. Contrariamente à programação declarativa, a programação
imperativa introduz um paradigma de programação que descreve a computação em termos de um
estado de um programa e ações que modificam esse estado, tal como o modo imperativo nas
linguagens naturais (faladas e escritas) expressa comandos para perfazer ações, as linguagens
imperativas expressam uma sequencia de comandos para um computador efetuar.
Visão simplificada da arquitetura de Von Neumann.

As linguagens de programação imperativa contrastam com outros tipos de linguagem, tais como
linguagens de programação declarativa, funcional e lógica. Linguagens de programação funcional,
como por exemplo Haskell, não são uma sequência de afirmações e não possuem, por consequência,
um estado global como as linguagens imperativas. Linguagens de programação lógica, como
exemplo Prolog, frequentemente definem "o que" é para ser computado, mais do que "como"
computar, como seria normal em uma linguagem imperativa.
Em linguagens puramente imperativas, como Assembly, é muito fácil o programador criar códigos
de difícil leitura, pois esse tipo de linguagem possui o que se chama de saltos (jumps) em sua
estrutura. Estes saltos funcionam da seguinte forma: o programador define uma marcação (label) no
código e depois, a partir de qualquer parte do programa, ele pode executar um desvio de fluxo de
execução (salto) para aquela marcação. Pode ser que à primeira vista isso não tenha problema,
contudo, na depuração do código, o programador fica em apuros com tantas marcações e saltos, pois
isso dificulta o entendimento do fluxo de execução do programa.
Neste contexto, surge a programação estruturada, como uma forma de possibilitar que o
programador tenha maior controle sobre o fluxo de execução do programa. Para isso, qualquer
programa pode ser reduzido a 3 estruturas:

 Estruturas de sequência: Onde uma tarefa é executada após a outra, linearmente.


 Estruturas de decisão: Onde, a partir de um teste lógico, determinado trecho de código é
executado, ou não.
 Estruturas de iteração: Onde, a partir de um teste lógico, determinado trecho de código é
repetido por um número finito de vezes.
Programação estruturada é uma forma de programação de computadores que preconiza que todos os
programas possíveis podem ser reduzidos a apenas três estruturas: sequência, decisão e iteração,
desenvolvida por Michael A. Jackson no seu livro "Principles of Program Design" de 1975.
Tendo, na prática, sido transformada na programação modular, a Programação estruturada orienta os
programadores para a criação de estruturas simples em seus programas, usando as subrotinas e as
funções. Foi a forma dominante na criação de software anterior à programação orientada por objetos.
Apesar de ter sido sucedida pela programação orientada por objetos, pode-se dizer que a
programação estruturada ainda é muito influente, uma vez que grande parte das pessoas ainda
aprendem programação através dela. Para a resolução de problemas relativamente mais simples e
diretos a programação estruturada é muito eficiente. Além disso, por exigir formas de pensar
relativamente complexas, a programação orientada a objetos até hoje ainda não é bem compreendida
ou usada pela maioria.
Há de se acrescentar também que inúmeras linguagens ainda extremamente relevantes nos dias de
hoje, como Cobol, PHP e Perl ainda utilizam o paradigma estruturado (muito embora possuam
suporte para a orientação à objetos).

Índice

 1Origens
 2Histórico
 3Características Principais da Linguagem Imperativa
 4Como Funciona a Programação Imperativa
 5Modelo Computacional do Paradigma Imperativo
 6Elementos da Programação Imperativa
 7Técnicas em Programação Imperativa
 8Vantagens
 9Desvantagens
 10Linguagens de programação
 11Leitura Recomendada
 12Ver também
 13Ligações externas

Origens[editar | editar código-fonte]


Linguagens imperativas têm uma história rica e variada. As primeiras linguagens de
programação imperativas eram linguagens de máquina, com instruções simples mas de construção
complexa. Instruções de máquina foram logo substituídos com linguagens de montagem que são
essencialmente transliterações de código de máquina.
Fortran (FORmula TRANslation) foi a primeira linguagem de alto nível para ganhar ampla
aceitação. Ele foi projetado para aplicações científicas e contou com uma notação algébrica, tipos,
subprogramas, e entrada/saída formatada. Foi implementado em 1956 por John
Backus na IBM especificamente para a máquina IBM 704. Execução eficiente foi uma grande
preocupação, consequentemente, sua estrutura e comandos têm muito em comum com linguagens de
montagem. FORTRAN ganhou ampla aceitação e continua a ser largamente utilizado na
comunidade de computação científica.
COBOL (COmmon Business Oriented Language) foi projetada (por um comitê de representantes de
fabricantes de computadores e do Departamento de Defesa), por iniciativa do Departamento de
Defesa dos EUA em 1959 e implementado em 1960. COBOL caracteriza registros, arquivos e dados
fixos decimais. Ele também forneceu uma linguagem natural como sintaxe para que os programas
sejam capazes de ser lido e entendido por não programadores. COBOL ganhou ampla aceitação na
comunidade de processamento de dados e continua a ser largamente utilizado.

Ken Thompson e Dennis Ritchie (da esquerda para direita), os criadores das linguagens B e C,
respectivamente.

ALGOL 60 (ALGorithmic Oriented Language) foi concebido em 1960 por um comitê internacional
para uso em resolução de problemas científicos. Ao contrário FORTRAN foi concebido de forma
independente de uma aplicação, uma escolha que conduzem a uma linguagem elegante. A descrição
do ALGOL 60 introduziu a notação BNF para a definição de sintaxe e é um modelo de clareza e
completude. Embora ALGOL 60 não conseguiu ganhar grande aceitação, introduziu estrutura de
bloco, instruções de controle estruturados e procedimentos recursivos no paradigma de programação
imperativa.

 FORTRAN (1956) → variáveis com nome, subprogramas, expressões complexas


 ALGOL (1960) → maior facilidade de expressar algoritmos matemáticos
 COBOL (1960)
 BASIC (1964) → sintaxe mais próxima do inglês
 PASCAL (1970)
 C (1970)
 ADA (1974-1983)

Histórico[editar | editar código-fonte]


 Computador Hipotético
 Introdução à Programação
 Construção de Algoritmos
 Componentes de Algoritmos
 Controle de Fluxo de Execução
 Estrutura de Decisão SE
 Estrutura de Decisão CASO

Características Principais da Linguagem


Imperativa[editar | editar código-fonte]
As linguagens imperativas também são chamadas de procedurais e se trata do modelo mais antigo de
todos, a execução é baseada em comandos e armazenamento de dados. O paradigma imperativo foi
predominante nas LP, pois são mais fáceis de traduzir para uma forma adequada para execução da
máquina. Um programa imperativo é mantido em variáveis que são associadas com localizações de
memória que correspondem a um endereço e um valor de armazenamento. O valor da variável pode
ser acessado direta ou indiretamente, e pode ser alterado através de um comando de atribuição. O
comando de atribuição introduz uma dependência de ordem no programa, ou seja, o valor da
variável pode se modificar antes e depois do comando e isso garante a sequencia de instruções.
As funções de linguagem de programação imperativa são descritas como algoritmos que especificam
como processar um intervalo de valores, a partir de um valor de domínio, com uma série de passos
descritos. A repetição é usada para processar os valores e laços para varrer uma sequencia de
localizações de memória (vetores, por exemplo), ou para acumular valor nas variáveis.

 Variáveis: modelam as células de memória


 Comandos de atribuição: são baseados nas operações de transferências de dados e instruções.
 Execução sequencial de procedimentos
 Forma interativa de repetição

Como Funciona a Programação Imperativa[editar | editar código-


fonte]
A essência da programação imperativa e também da Máquina de Turing se resume a três conceitos:

 A descrição de estados de uma máquina abstrata por valores de um conjunto de variáveis


 Reconhecedores desses estados - expressões compostas por relações entre esses valores ou os
resultados de operações utilizando valores
 Comandos de atribuição e controle
O código fonte dos programas e computador, seguindo o paradigma imperativo possui marcações
especiais (implíticas ou explícitas) que direcionam a sua execução pelo sistema operacional e, em
última análise, pelo hardware. Embora as linguagens de programação modernas pertencentes a
outros paradigmas tendam a facilitar cada vez mais a escrita do código, camuflando operações mais
próximas às linguagens de baixo nível, podemos encontrar ainda a presença de estruturas de controle
da mesma forma que ocorria em linguagens de programação de vinte ou trinta anos atrás.
As marcações utilizadas para controlar a execução dos programas são chamadas de estruturas de
controle. As estruturas de controle são divididas em três grupos: sequência, seleção e repetição. A
estrutura de sequência é implícita nos programas e indica que as instruções são executadas uma após
a outra, seguindo uma sequência.

Modelo Computacional do Paradigma Imperativo[editar | editar


código-fonte]
Programas centrados no conceito de um estado (modelado por variáveis) e ações (comandos) que
manipulam o estado, são programas projetados em um paradigma imperativo, paradigma esse que
também é denominado de procedural, por incluir subrotinas ou procedimentos como mecanismo de
estruturação. Foi o primeiro paradigma a surgir e ainda é o dominante.
O paradigma imperativo está baseado na ideia de um estado que sofre modificações durante
a computação. O estado é representado por um conjunto de associações de identificadores (variáveis
globais e locais ativas do programa) em valores. A diferença fundamental com relação ao paradigma
funcional é que esta associação é dinâmica, sendo constantemente modificada durante a execução de
um programa. As linguagens imperativas oferecem uma variedade de comandos cuja execução
envolve aspectos de controle, mas essencialmente modificação do estado do programa.
O elemento central de um programa imperativo é o comando, que pode ser primitivo (como
atribuição, leitura e escrita) ou composto, como seqüência, condicional e iteração. Um importante
mecanismo de estruturação das linguagens imperativas é o procedimento, que, como uma função,
pode ser parametrizado, mas tem como corpo um comando, ao invés de uma expressão. Em geral,
um programa em uma linguagem imperativa deixa de ser uma expressão e passa a ser um comando.

Elementos da Programação Imperativa[editar | editar código-fonte]


Os principais elementos da programação imperativa são:

 Definição de tipos de dados


 Expressões e atribuições
 Estruturas de controle de fluxo (programação estruturada)
 Definição de sub-rotinas (programação procedimental)

Técnicas em Programação Imperativa[editar | editar código-fonte]


 Modularidade dos Algoritmos (Programação estruturada)
 Modularidade das Estruturas de dados (Tipos abstratos de dados)
 Recorrência

Vantagens[editar | editar código-fonte]


 Eficiência (embute o modelo Von Neumann)
 Paradigma dominante e bem estabelecido
 Modelagem natural de aplicações do mundo real
 Possui tipagem fraca e também muito flexível (alguns especialistas consideram isso uma
desvantagem)
 É fácil de se entender, sendo amplamente usada em cursos introdutórios de programação.

Desvantagens[editar | editar código-fonte]


 Possui difícil legibilidade
 Descrições demasiadamente profissional focaliza o "como" e não o "quê"
 Relacionamento indireto com a E/S (indução a erros/estados)
 Ainda se foca em como a tarefa deve ser feita e não em o que deve ser feito.
 Tende a gerar códigos confusos, onde tratamento dos dados são misturados com o
comportamento do programa

Linguagens de programação[editar | editar código-fonte]


Alguns exemplos de linguagens de programação que baseiam-se no modelo imperativo:

 Ada
 ALGOL
 Basic
 C
 PHP
 Java
 Cobol
 Fortran
 Pascal
 Python
 Lua
 Mathematica

Leitura Recomendada[editar | editar código-fonte]


Pratt, Terrence W. e Marvin V. Zelkowitz. Línguas De Programação: Projeto e execução. ó ed.
Penhascos De Englewood, N.J.: Prentice Salão, 1996.
Sebesta, Robert W. Conceitos de línguas de programação. ó ed. Leitura, Massa.: Addison-Wesley
Publishing Companhia, 1996.

Ver também[editar | editar código-fonte]


 Paradigma de programação
 Linguagem de programação
 Programação funcional
 Programação procedural
 Programação orientada a objetos
 Programação estruturada

Ligações externas[editar | editar código-fonte]


 Linha do tempo das linguagens

 Portal de biografias
Categorias:

 Nascidos em 1903
 Mortos em 1957
 Paradigmas de programação
Menu de navegação
 Não autenticado
 Discussão

 Contribuições

 Criar uma conta

 Entrar
 Artigo
 Discussão
 Ler
 Editar
 Editar código-fonte
 Ver histórico
Busca
Ir

 Página principal
 Conteúdo destacado
 Eventos atuais
 Esplanada
 Página aleatória
 Portais
 Informar um erro
 Loja da Wikipédia
Colaboração
 Boas-vindas
 Ajuda
 Página de testes
 Portal comunitário
 Mudanças recentes
 Manutenção
 Criar página
 Páginas novas
 Contato
 Donativos
Imprimir/exportar
 Criar um livro
 Descarregar como PDF
 Versão para impressão
Ferramentas
 Páginas afluentes
 Alterações relacionadas
 Carregar ficheiro
 Páginas especiais
 Hiperligação permanente
 Informações da página
 Elemento Wikidata
 Citar esta página
Noutras línguas
 ‫العربية‬
 Deutsch
 English
 Español
 Français
 日本語
 Bahasa Melayu
 Русский
 中文
30 outras
Editar hiperligações

 Esta página foi editada pela última vez às 15h08min de 5 de agosto de 2018.
 Este texto é disponibilizado nos termos da licença Atribuição-CompartilhaIgual 3.0 Não Adaptada (CC BY-SA
3.0) da Creative Commons; pode estar sujeito a condições adicionais. Para mais detalhes, consulte
as condições de utilização.

 Política de privacidade

 Sobre a Wikipédia

 Avisos gerais

 Programadores

 Declaração sobre ''cookies''

 Versão móvel