Guia Visual G e linguagem C

Prévia do material em texto

1) Introdução à Linguagem C e 
equivalências das sintaxes entre 
VisuAlg x Linguagem C
UNIVAP - Universidade do Vale do Paraíba
IP&D - Instituto de Pesquisa e Desenvolvimento
Mestrado em Física e Astronomia
Mestrando e Estagiário Docente Marco Antônio de Ulhôa Cintra
Disciplina Lógica para Programação - FEAU – Prof. Dr. Carlos Lahoz
História da Linguagem C 
O que é a linguagem C? É uma linguagem de programação amplamente utilizada
desenvolvida no início dos anos 1970 nos Laboratórios Bell, por Ken Thompson,
Dennis Ritchie, e outros.
Livro referência “The C Programming Language”, escrito por Brian Kernighan e
Dennis Ritchie, e publicado em 1978.
Forças e Fraquezas da Linguagem C
- C é uma linguagem de baixo nível. Para servir como uma linguagem adequada
para programação de sistemas, C prove acesso à conceitos de nível de máquina.
(bytes e endereços, por exemplo) que outras linguagens de programação tentam
esconder.
- C é uma linguagem pequena. C prove um conjunto mais limitado de
características do que muitas linguagens.
- C é uma linguagem permissiva. C assume que você saiba o que você está
fazendo, permitindo um alto grau de liberdade, em comparação com muitas
linguagens. C não obriga a checagem de erros, encontrada em outras linguagens.
Forças da Linguagem C
- Eficiência. Eficiência sempre foi uma das vantagens do C desde o começo.
Como o C foi implementado para aplicações onde a linguagem assembly era
tradicionalmente utilizada, foi crucial que programas em C pudessem executar
rapidamente em quantidades limitadas de memória.
- Portabilidade. Apesar do objetivo principal do C não ser a portabilidade do
programa, se tornou uma de suas forças. Quando um programa deve rodar em
computadores de PCs até supercomputadores, é frequentemente escrito em C.
- Força. A grande coleção de tipos de dados e operadores ajudam a fazer do C
uma ponderosa linguagem. Com o C, é possível realizar o desejado com poucas
linhas de código.
Forças da Linguagem C
- Flexibilidade. Apesar do C ter sido originalmente feito para programação de
sistemas, não herdou restrições que limitavam seu uso a esse ambiente. C é
utilizado para aplicações de todos os tipos, de sistemas embarcados até
processamento de dados comerciais.
- Biblioteca padrão. Uma das grandes forças do C é sua biblioteca padrão, que
contém cenenas de funções para entrada/saída, operações com strings, alocação
de armazenamento, e outras operações úteis.
- Integração com UNIX. C é particularmente poderoso em combinação com o
UNIX (incluindo a popular variante conhecida como Linux). De fato, algumas
ferramentas UNIX assumem que o usuário conheça C.
Fraquezas da Linguagem C
- Programas em C podem ser propensos a erros. A flexibilidade do C faz dela
uma linguagem propensa a erros. Erros de programação que poderiam ser
capturados em muitas outras linguagens não podem ser detectados por um
compilador C, somente quando o programa é executado. O C também contém
armadilhas.
- Programas em C podem ser difíceis de entender. Apesar do C ser uma
pequena linguagem, tem um número de características que não são encontradas
em outras linguagens de programação. Elas podem ser combinadas com grande
variedade, muita das quais, apesar de óbvio para o autor original do programa,
podem ser difíceis para outros entenderem.
Fraquezas da Linguagem C
- Programas em C podem ser difíceis de se modificar. Grandes programas
escritos em C podem ser difíceis de se modificar se eles não foram projetados
com a manutenção em mente. Linguagens de programação modernas
geralmente provêem características como classes e pacotes que suportam a
divisão de um grande programa em peças mais gerenciáveis. C, infelizmente,
não possui essas características.
Uso Efetivo da Linguagem C
- Aprenda a evitar armadilhas. Dicas: C Programming – A Modern Approach –
K. N. King; e C Traps and Pitfalls – Andrew Koenig’s.
- Use ferramentas de software para fazer programas mais confiáveis. Uma das
mais famosas ferramentas em C é chamada lint, provida com o UNIX, pode
sujeitar um programa a uma análise mais extensiva de erros do que a maioria
dos compiladores C. Outra ferramenta útil é um debugger. Por causa da
natureza do C, muitos bugs não podem ser detectados por um compilador C;
estes aparecem na forma de erros em tempo de execução, ou saída incorreta.
Consequentemente, usar um bom debugger é praticamente mandatório para
programadores C.
Uso Efetivo da Linguagem C
- Leve vantagem de bibliotecas de código existentes. Um dos benefícios de
usar C é que muitas outras pessoas também usam elas. É uma boa aposta que já
escreveram código que você pode empregar em seus próprios programas.
Código C está frequentemente cheio de bibliotecas (coleções de funções): obter
uma adequada biblioteca é um bom modo de reduzir erros e salvar considerável
esforço de programação.
- Adote um conjunto sensível de convenções de código. Uma convenção de
código é uma regra de estilo que um programador decidiu adotar mesmo apesar
de seu uso não ser obrigado pela linguagem. Convenções bem escolhidas
ajudam a tornar os programas mais uniformes, fáceis de ler e de modificar.
Convenções são importantes ao usar qualquer linguagem de programação, mas
especialmente o C.
Uso Efetivo da Linguagem C
- Evite truques e código excessivamente complexo. C encoraja truques de
programação. Existem geralmente vários modos de cumprir uma dada tarefa em
C: programadores são frequentemente seduzidos a escolher o método que é
mais conciso. Não caia nisso; a solução mais curta é frequentemente a mais
difícil de se compreender. O ideal é um estilo que é razoavelmente conciso, mas
ainda compreensivo.
- Fique com o padrão. A maioria dos compiladores C provêem características da
linguagem e funções da biblioteca que não fazem parte do padrão C89 ou C99.
Para portabilidade, é melhor evitar usar características não padrões e bibliotecas
a menos que eles sejam absolutamente necessários.
Estrutura mínima de programa Visualg X Linguagem C
algoritmo "semnome"
// Função :
// Autor :
// Data :
// Seção de Declarações
inicio
// Seção de Comandos
fimalgoritmo
VisuAlg:
C: // algoritmo “semnome”
int main(void)
{ // Início
// Função :
// Autor :
// Data :
// Seção de Declarações
} // Fim
Escrevendo um simples programa
C: olamundo.c
// algoritmo “olamundo”
#include <stdio.h>
int main(void)
{
printf(“Olá, mundo!\n”);
system("pause");
return 0;
} 
VisuAlg: olamundo.alg
algoritmo “olamundo“
inicio
escreval(“Olá, mundo!”);
fimalgoritmo 
Escrevendo um simples programa
C:
A linha #include <stdio.h>: é necessário incluir informação sobre a biblioteca
padrão do C de entrada/saída. O código então prossegue dentro do main, que
representa o programa principal. A única linha dentro do main é um comando
para mostrar a mensagem desejada. printf é uma função da biblioteca de
entrada/saída que pode produzir saída formatada. O \n diz ao printf para
avançar para a próxima linha após imprimir a mensagem. A linha return 0;
indica que o programa retorna o valor 0 para o sistema operacional quando este
terminar.
Compilação e “linkagem”
Para executar o código olamundo.c, envolve mais do que se espera. Primeiro
precisamos criar um arquivo chamado olamundo.c contendo o programa
(qualquer arquivo de texto faz isso). O nome do arquivo não importa, mas a
extensão .c é frequentemente requerida pelos compiladores. Precisamos converter
o programa em uma forma que a máquina possa executar. Para o programa em C,
geralmente envolve três etapas:
1) Preprocessamento. O programa é primeiro dado a um preprocessador, que
obedece comandos que iniciam com # (conhecidocomo diretivas). Um
preprocessador é como um editor; pode adicionar coisas ao programa e fazer
modificações.
Compilação e “linkagem”
2) Compilação. O programa modificado agora vai para um compilador, que o
traduz em instruções de máquina (código objeto). O programa ainda não está
pronto para ser executado, ainda, no entanto.
3) “Linkagem”. No passo final, um linker combina o código objeto produzido
pelo compilador com quaisquer códigos necessários para produzir um programa
executável completo. O código adicional inclui funções de biblioteca (como o
printf) que são usados no programa.
Felizmente este processo é automatizado. De fato, o preprocessador é geralmente
integrado com o compilador, então você provavelmente não vai notar seu
trabalho.
Compilação e “linkagem”
Os comandos necessários para compilar e “linkar” variam, dependendo do compilador e
sistema operacional. No UNIX, o compilador C é geralmente chamado cc. Para compilar
e “linkar” o programa olamundo.c, entre com o seguinte comando em um terminal ou
janela de linha de comando:
% cc olamundo.c
(O caractere % é o prompt do UNIX, não algo que você precise digitar).
A linkagem é automática ao usar o cc, nenhum comando de link é necessário.
Depois de compilar e “linkar” o programa, cc deixa o programa executável em um
arquivo chamado a.out por padrão. Se quisermos que a versão executável do
olamundo.c seja chamada de olamundo, escrevemos a seguinte linha de comando:
% cc –o olamundo olamundo.c
Compilador GCC
Um dos mais populares compiladores C é o compilador GCC, que é fornecido com o
Linux, mas está disponível em muitas outras plataformas. Para executar o programa
olamundo.c , usamos o seguinte comando:
% gcc –o olamundo olamundo.c
Ambientes Integrados de Desenvolvimento (IDEs)
A alternativa de executar um programa em C, sem utilizar uma linha de comando, é usar
um ambiente integrado de desenvolvimento (IDE), um pacote de programas que nos
permitem editar, compilar, “linkar”, executar, e até mesmo depurar (debug) um programa
sem deixar o ambiente. Quando o compilador detecta um erro em um programa, a IDE
pode destacar a linha que contém o erro.
Dev-C++
• https://sourceforge.net/projects/orwelldevcpp/
• http://orwelldevcpp.blogspot.com.br/
Versão portable: 
http://sourceforge.net/projects/orwelldevcpp/files/Portable%20Releases/Dev-
Cpp%205.11%20No%20Compiler%20Portable.7z/download
Manual:
1) Menu Ajuda>Ajuda sobre o Dev-C++
2) http://wiki.icmc.usp.br/images/e/e3/Manual_Dev_C.pdf
Funções numéricas, algébricas e trigonométricas no VisuAlg X C
#include <stdio.h>
#include <math.h>
Abs (expressão) / float a = fabs (expressão)- Retorna o valor absoluto de uma expressão 
do tipo inteiro ou real. Equivale a | expressão | na álgebra.
ArcCos(expressão) / float a = acos(expressão) - Retorna o ângulo (em radianos) cujo co-
seno é representado por expressão.
ArcSen( expressão) / float a = asin(expressão) - Retorna o ângulo (em radianos) cujo 
seno é representado por expressão.
ArcTan( expressão) / float a = atan(expressão) - Retorna o ângulo (em radianos) cuja 
tangente é representada por expressão.
Cos(expressão) / float a = cos(expressão) - Retorna o co-seno do ângulo (em radianos) 
representado por expressão.
CoTan(expressão) / float a = 1/(tan(expressão)) - Retorna a co-tangente do ângulo (em 
radianos) representado por expressão.
Exp(base, expoente) / float a = pow(base, expoente) - Retorna o valor de base elevado 
a expoente, sendo ambos expressões do tipo real.
GraupRad(expressão) / float a = expressão * (180.0 / 3.1415926535) - Retorna o valor em 
radianos correspondente ao valor em graus representado por expressão.
Int(expressão) / int a = (int) expressão - Retorna a parte inteira do valor 
representado por expressão.
Log(expressão) / float a = log10(expressão) - Retorna o logaritmo na base 10 do valor 
representado por expressão.
LogN(expressão) / – float a = log(expressão) - Retorna o logaritmo neperiano (base e) do valor 
representado por expressão.
Pi / #define M_PI 3.14159265358979323846. Depois utilize a variável M_PI.
Quad(expressão) / float a = pow(base, 2) - Retorna quadrado do valor representado por expressão.
RadpGrau(expressão) / float a = tan(expressão * M_PI / 180) - Retorna o valor em graus 
correspondente ao valor em radianos representado por expressão.
RaizQ(expressão) / float a = sqrt(expressão) - Retorna a raiz quadrada do valor representado por 
expressão.
Rand / para retornar número aleatório na faixa [M,N], no caso, [0,1], faça: float a = M + rand() 
/ (RAND_MAX / N – M + 1) + 1), convertendo: float a = 0 + rand() / (RAND_MAX / 1 – 0 + 1) + 1) -
Retorna um número real gerado aleatoriamente, maior ou igual a zero e menor que um.
RandI(limite) / para retornar número aleatório na faixa [M,N], no caso, [0,N], faça: float a = 0
+ rand() / (RAND_MAX / N – 0 + 1) + 1) - Retorna um número inteiro gerado aleatoriamente, maior 
ou igual a zero e menor que limite.
Sen(expressão) / float a = sin(expressão) - Retorna o seno do ângulo (em radianos) representado 
por expressão.
Tan(expressão) / float a = tan(expressão) - Retorna a tangente do ângulo (em radianos) 
representado por expressão.
Funções numéricas, algébricas e trigonométricas no VisuAlg X C
#include <stdio.h>
#include <math.h>
Funções para manipulação de cadeias de caracteres (strings) no VisuAlg X C
#include <stdio.h>
#include <string.h>
Asc (s: caracter): 
char meuTexto[] = “Isto é um pouco de texto”;
int s = meuTexto[0];
Retorna um inteiro com o código ASCII do primeiro caracter da expressão.
Carac (c: inteiro): 
char meuchar = c + ‘0’;
Retorna o caracter cujo código ASCII corresponde à expressão.
Caracpnum (c: caracter): 
char meuchar[] = “450”;
int result = atoi(meuchar);
Retorna o inteiro ou real representado pela expressão. Corresponde a 
StrToInt() ou StrToFloat() do Delphi, Val() do Basic ou Clipper, etc.
Compr (c: caracter):
int tamanho = strlen(c)
Retorna um inteiro contendo o comprimento (quantidade de caracteres) da 
expressão. 
Copia (ct: caracter; s, n: inteiro):
strncpy(string_destino, string_origem, tamanho);
Retorna um valor do tipo caracter contendo uma cópia parcial da expressão, a 
partir do caracter p, contendo n caracteres. Os caracteres são numerados da 
esquerda para a direita, começando de 1. Corresponde a Copy() do Delphi, 
Mid$() do Basic ou Substr() do Clipper.
Int (r: real):
int = (int) r;
Retorna o inteiro representado pela expressão.
Funções para manipulação de cadeias de caracteres (strings) no VisuAlg X C
#include <stdio.h>
#include <string.h>
Maiusc (c: caracter):
char letra = toupper(c);
Retorna um valor caracter contendo a expressão em maiúsculas.
int i = 0;
char texto[] = "Olá, mundo!";
char maiusc[20];
while(texto[i]){
maiusc[i] = toupper(texto[i]);
i++;
}
printf("%s", maiusc);
Retorna um valor string contendo a expressão em maiúsculas.
Saída: OLÁ, MUNDO!
Funções para manipulação de cadeias de caracteres (strings) no VisuAlg X C
#include <stdio.h>
#include <string.h>
Minusc (c: caracter):
char letra = tolower(c);
Retorna um valor caracter contendo a expressão em minúsculas.
int i = 0;
char texto[] = "OLÁ, MUNDO!";
char minusc[20];
while(texto[i]){
minusc[i] = tolower(texto[i]);
i++;
}
printf("%s", minusc);
Retorna um valor string contendo a expressão em minúsculas.
Numpcarac (n: inteiro ou real):
int alguminteiro = 368;
char str[12]
sprintf(str, “%d”, alguminteiro);
Retorna um valor caracter contendo a representação de n como uma cadeia de caracteres. 
Corresponde a IntToStr() ou FloatToStr() do Delphi, Str() do Basic ou Clipper.
Funções paramanipulação de cadeias de caracteres (strings) no VisuAlg X C
#include <stdio.h>
#include <string.h>
Pos (subc, c: caracter): 
char texto[40] = “programa de computador”
char achar = ‘g’;
const char *ptr = strchr(texto, achar);
If(ptr) {
int indice = ptr – texto;
}
Retorna um inteiro que indica a posição em que a cadeia subc se encontra em c, ou zero se subc não
estiver contida em c. Corresponde funcionalmente a Pos() do Delphi, Instr() do Basic ou At() do Clipper,
embora a ordem dos parâmetros possa ser diferente em algumas destas linguagens.
Funções para manipulação de cadeias de caracteres (strings) no VisuAlg X C
#include <stdio.h>
#include <string.h>
Funções especiais - VisuAlg X C
#include <stdio.h>
• Leia(variável_nome):
Lê do teclado e coloca em uma variável 'variável_nome’
A função scanf (abreviatura de scan formatted) lê do teclado uma lista de números, caracteres, strings, etc. O
primeiro argumento da função é uma string que especifica o formato da lista a ser lida. Os demais argumentos são
os endereços das variáveis onde os valores lidos devem ser armazenados. A função trata todos os brancos como
se fossem espaços (caracteres ' ').
Fonte: https://www.ime.usp.br/~pf/algoritmos/aulas/io.html
Funções especiais - VisuAlg X C
#include <stdio.h>
#include <stdlib.h>
• Leia(variável_nome):
Lê do teclado e coloca em uma variável 
'variável_nome’
scanf()
#include <stdio.h>
#include <stdlib.h>
int main (void) {
int a, b;
scanf ("%d %d", &a, &b);
double media;
media = (a + b)/2.0;
printf ("A média de %d e %d é %f\n", a, b, 
media);
system("pause");
return 0;
}
Fonte: 
https://www.ime.usp.br/~pf/algoritmos/aulas/io.html
https://www.juliobattisti.com.br/tutoriais/katiaduarte/cbasico005.asp
%c Caracteres simples
%d Inteiros decimais com sinal
%I Inteiros decimais com sinal
%e Notação cientifica (e minúsculo)
%E Notacão cientifica (E maiúsculo)
%f Ponto flutuante decimal
%g Usa %e ou %f (qual for mais curto)
%G Isa %E ou %F (qual for mais curto)
%o Octal sem sinal
%s Cadeia de caracteres
%u Inteiros decimais sem sinal
%x Hexadecimal sem sinal (letras minúsculas)
%X Hexadecimal sem sinal (letras maiúsculas)
%% Escreve o símbolo de porcentagem (%)
Código
formatação
Descrição
Declaração de variáveis e constantes - VisuAlg X C
var x: real
y: inteiro
a: caractere
l: logico
float x;
int y;
char a;
typedef enum { false, true } bool;
bool b;
#define PI 3.14159265 
// ou
const float PI 3.14159265
//Constante. Não há equivalente em 
VisuAlg
VisuAlg: C:
Declaração de variáveis e constantes - VisuAlg X C
- Trabalhando com textos
• VisuAlg: 
Algoritmo "trabalhandocomtexto"
Var
nomecompleto: caractere
Inicio
escreva("Digite seu nome completo: ")
leia (nomecompleto)
escreva("Seu nome completo é: " , nomecompleto)
Fimalgoritmo
Declaração de variáveis e constantes - VisuAlg X C
- Trabalhando com textos
• C:
#include <stdio.h>
int main(void)
{
char nomecompleto[100];
printf(“Digite seu nome completo: ");
gets(nomecompleto); //Função para ler texto do usuário
printf(“Seu nome completo é: ");
puts(nomecompleto); //Função para exibir texto
return 0;
}
Note que a função scanf pode receber texto contendo palavra única, para receber textos contendo espaços, utilize a função
gets. Exemplo: se o nome digitado foi “João da Silva”, a função gets faz com que a variável recebe o nome completo “João da
Silva”; caso fosse utilizada a função scanf (ao invés da função gets), a variável receberia apenas o texto “João”. Em relação à
utilização da função puts, ela facilita o trabalho com textos, mas a função printf também pode ser utilizada.
Operadores aritméticos
C: tudo igual 
Operadores aritméticos
#include <stdio.h>
#include <math.h>
C:
Radiciação - float a = sqrt(expressão)
Potenciação - float a = pow(base, 
expoente)
VisuAlg: Radiciação - Raizq(expressão)
Potenciação – Exp(base, expoente)
ou
utilizando “^” (base ^ expoente)
Operadores aritméticos
C:
Resto da divisão: utiliza-se somente %: float resto = 9 % 4 (resulta em 1);
Quociente da divisão: int quociente = 9 / 4 (resulta em 2)
VisuAlg:
Resto da divisão: também pode ser utilizado o “%” (9 % 4) (resulta em 1)
Quociente da divisão: também pode ser utilizada o “\” (9 \ 4) (resulta em 2)
Operadores de caracteres
#include <string.h> 
VisuAlg:
+
Operador de concatenação de strings (isto é, cadeias de caracteres), quando
usado com dois valores (variáveis ou constantes) do tipo "caractere". Por
exemplo: "Rio " + " de Janeiro" = "Rio de Janeiro".
C:
A linguagem C não tem suporte para concatenação de string como outras linguagens
possuem.
Não há operador de concatenação no C. Use strcat para concatenar duas strings:
char string1[20], string2[20], string3[20];
string1 = “Rio de ”;
string2 = “Janeiro”;
string3 = strcat(string1, string2);
Prioridades entre operadores aritméticos
VisuAlg: igual
C: igual, lembrando apenas que os
operadores pot e rad são realizados de
forma diferente em C.
Operadores relacionais
VisuAlg: igual 
C: exceções:
Igual a: ==
Diferente de: !=
Operadores lógicos
VisuAlg: xou: Operador que resulta VERDADEIRO se seus dois operandos lógicos forem
diferentes, e FALSO se forem iguais. Equivale ao XOR do Pascal.
C:
não: !
e: &&
ou: ||
xor: ^
Tabelas-verdade
VisuAlg: igual
C: igual
Tabelas-verdade
VisuAlg: igual
C: igual
Tabelas-verdade
VisuAlg: igual
C: igual
Prioridades entre operadores lógicos
VisuAlg: igual
C: igual
Prioridades entre operadores lógicos
VisuAlg: igual
C: igual
Comando de atribuição
VisuAlg: sem ponto e vírgula no final 
C: meuinteiro = 2;
Entrada de dados
#include <stdio.h>
VisuAlg: sem ponto e vírgula no final 
C:
scanf();
ou
gets();
//para receber textos (char[])
Saída de dados
#include <stdio.h>
VisuAlg: sem ponto e vírgula no final 
C: 
printf();
ou
puts();
//para exibir textos (char[])
Blocos
VisuAlg:
algoritmo “bloco"
// Função :
// Autor :
// Data :
// Seção de Declarações
inicio
// Seção de Comandos
fimalgoritmo
#include <stdio.h>
#include <stdlib.h>
//Verificar necessidade de uso da biblioteca 
int main (void) {
//seção de comandos
/* multi
Comentários
*/
}
C: 
Estruturas de seleção (simples e/ou composta)
VisuAlg: sem til em “então”, sem til em “senão”, e sem ponto e vírgula no final 
C:
if (<expressão>){
//ação 
else{
//ação
}
Estruturas de seleção (com múltipla escolha)
VisuAlg: 
Exceção – ao 
invés de “caso 
contrário”, 
usa-se 
“outrocaso”
, e sem ponto 
e vírgula no 
final
C:
switch(<valor>){
case <constante>: 
//ação
case <constante>:
//ação
default: 
//caso contrário
//ação
}
OBS.: valor 
constante deve ser 
uma variável 
inteira.
Estruturas de repetição (teste no início)
VisuAlg: sem cedilha em “faça”, e sem ponto e vírgula no 
final 
C:
while(<expressão>){
//ação
}
Estruturas de repetição (com teste no final)
VisuAlg: sem acento em “até”, e sem ponto e vírgula no final
C: não existe esta estrutura em C, apenas uma semelhante (do while), a diferença é
que a condição de existência do do while é verdadeira, ao passo que a condição de
existência do repita é falsa. No repita, na primeira vez que i seja menor que 100, o
loop terminaria, porém com o do while, o loop só terminará quando i for igual ou
maior que 100.
Exemplo da estrutura do while:
do{
//ação
}while(i<100);
Comando interrompa
VisuAlg:algoritmo "Números de 1 
a 10 (com interrompa)"
var x: inteiro
inicio
x <- 0
repita
x <- x + 1
escreva (x:3)
se x = 10 entao
interrompa
fimse
ate falso
fimalgoritmo
C:
Funciona no C para todas as estruturas
(for, while, do e switch), utilizando o comando
break;
Exemplo:
switch(numero_ticket)
{
case 35:
printf(“Parabéns! Você ganhou o primeiro prêmio!");
system("pause");
break;
case 122:
printf(“Você tem sorte. Ganhou o Segundo prêmio.");
system("pause");
break;
case 78:
printf(“Você tem sorte. Ganhou o terceiro prêmio.");
system("pause");
break;
default:
printf(“Que pena. Você perdeu.");
system("pause");
break;
}
Estruturas de repetição (com variável de controle)
VisuAlg: sem acento em “até”, sem cedilha em “faça”, e sem ponto e vírgula no final 
C:
for(expr1 <variáveldecontrole>; expr2 <de operador até operador>; expr3 <passo operador>){
//ação 
} 
Exemplo:
for(i=0; i<10; i++){
//ação 
} 
Comparação entre as estruturas de repetição
VisuAlg: tudo igual 
C: igual, porém não existe a estrutura repita no C. No C existe estrutura semelhante,
o do while:
Estrutura Condição Quantidade de Execuções Condição de Existência
do while Final mínimo 1 condição verdadeira 
Declaração e manipulação de variáveis compostas homogêneas
1) unidimensionais – vetores
VisuAlg: 
<lista-de-variáveis> : vetor “[“<lista-de-intervalos>”]” de <tipo-de-dado>
C: 
<tipo-de-dado> <variável> “[“<tamanho>”]” 
Declaração e manipulação de variáveis compostas homogêneas
1) unidimensionais – vetores
VisuAlg: 
vet: vetor [0..10] de real
vet[0] <- vet[1] + (a * 3)
C: 
int vet[11]; // vetor de 0 até 10 índices possui 11 posições
vet[0] = vet[0] + (a*3);
Declaração e manipulação de variáveis compostas homogêneas
2) multidimensionais – matrizes
VisuAlg: 
<lista-de-variáveis> : vetor “[“<lista-de-intervalos>”]” <,> “[“<lista-de-intervalos>”]” de 
<tipo-de-dado>
C: 
<tipo-de-dado> <variável> “[“<tamanho>”]” “[“<tamanho>”]”
//bidimensional. Para maiores dimensões, repetir “[“<tamanho>”]” n vezes.
Declaração e manipulação de variáveis compostas homogêneas
2) multidimensionais – matrizes
VisuAlg: 
matriz: vetor [0..4,0..10] de inteiro
matriz[3,9] <- a/4 - 5
C: 
int matriz[5][11]; // linha da matriz de 0 até 4 índices, possuindo 5 posições, e coluna da matriz 
de 0 até 10 índices, possuindo 11 posições.
matriz[3][9] = a/4 – 5;
int matriz[10][10][10][10]; // matriz de 4 dimensões
matriz[5][5][5][8] = 9;
Declaração e manipulação de variáveis compostas heterogêneas (registros)
Declaração e manipulação de variáveis compostas heterogêneas (registros)
• VisuAlg: não existentes.
• C: existentes. Exemplo:
struct fruta
{
char nome[15];
int calorias;
};
struct fruta a;
a.calorias = 157;
Arquivos
Arquivos
Arquivos
Arquivos
arquivo <nome-de-arquivo>VisuAlg: 
<nome-de-arquivo> é uma constante caractere (entre aspas duplas)
algoritmo "lendo do arquivo"
arquivo "teste.txt"
var x,y: inteiro
inicio
para x de 1 ate 5 faca
leia (y)
escreval (y)
fimpara
fimalgoritmo
Arquivos
C: 
#include <stdio.h>
int main(void)
{
int num;
FILE *fptr;
if ((fptr = fopen("C:\\programa.txt","r")) == NULL){
printf("Erro ao abrir arquivo");
system("pause");
// Programa termina se o ponteiro do arquivo retornar NULL.
exit(1);
}
fscanf(fptr,"%d", &num);
printf("Valor de n=%d", num);
system("pause");
fclose(fptr); 
return 0;
} 
Declaração e manipulação de modularização de algoritmos (procedimentos sem 
ou com retorno de valores)
Declaração e manipulação de modularização de algoritmos (procedimentos
sem retorno de valores)
VisuAlg: 
procedimento <nome-de-procedimento> [(<sequência-de-declarações-de-parâmetros>)]
// Seção de Declarações Internas
inicio
// Seção de Comandos
fimprocedimento
C: 
void <nome-da-função> [(<tipo-de-dado> <seqüência-de-declarações-de-parâmetros>)] 
// Seção de Declarações Internas
{
// Seção de Comandos
}
(função sem retorno de valor)
void <nome-da-função> [(<tipo-de-dado> <seqüência-de-declarações-de-parâmetros>)];
(definição do protótipo)
Declaração e manipulação de modularização de algoritmos (procedimentos 
com retorno de valores)
VisuAlg: 
funcao <nome-de-função> [(<sequência-de-declarações-de-parâmetros>)]: <tipo-de-
dado>
// Seção de Declarações Internas
inicio
// Seção de Comandos
fimfuncao
C: 
<tipo_de_retorno> <nome-da-função> [(<tipo-de-dado> <seqüência-de-declarações-de-
parâmetros>)] 
// Seção de Declarações Internas
{
// Seção de Comandos
}
(função com retorno de valor)
<tipo_de_retorno> <nome-da-função> [(<tipo-de-dado> <seqüência-de-declarações-de-
parâmetros>)];
(definição do protótipo)
Declaração e manipulação de modularização de algoritmos – procedimento 
sem passagem de parâmetros (com contexto de ação – não há retorno de 
valor)
VisuAlg: procedimento soma
var aux: inteiro
inicio
// n, m e res são variáveis globais
aux <- n + m
res <- aux
fimprocedimento 
No programa principal deve haver os seguintes comandos:
n <- 4
m <- -9
soma
escreva(res)
Declaração e manipulação de modularização de algoritmos – procedimento 
sem passagem de parâmetros (com contexto de ação – não há retorno de 
valor)
void soma(void);
void soma (void){ /*void antes do nome do programa significa que o programa não 
retorna nenhum valor, e o void no local de entrada de parâmetro da função 
significa que o programa não recebe parâmetro*/
int aux;
//inicio
// n, m e res são variáveis globais
aux = n + m;
res = aux;
}
No programa principal deve haver os seguintes comandos:
int main (void){
n = 4;
m = -9;
soma();
printf("%d\n", res);
system("pause");
}
C: 
void soma(void);
int n, m, res = 0;
int main(void)
{
n = 4;
m = -9;
soma();
printf("%d\n", res);
system("pause");
return 0;
}
void soma(void) {
int aux;
aux = n + m;
res = aux;
}
#include <stdio.h>
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros por valor (com contexto de ação - não há 
retorno de valor)
VisuAlg: procedimento soma (x,y: inteiro)
inicio
// res é variável global
res <- x + y
fimprocedimento 
No programa principal deve haver os seguintes comandos:
n <- 4
m <- -9
soma(n,m)
escreva(res)
void soma(int x, int y);
void soma (int x, int y){
// res é variável global
res = x + y;
}
No programa principal deve haver os seguintes comandos:
n = 4;
m = -9;
soma(n,m);
printf("%d\n", res);
system("pause");
C: 
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros por valor (com contexto de ação - não há 
retorno de valor)
int res = 0;
void soma(int x, int y);
void soma(int x, int y) {
res = x + y;
}
int main(void) {
int n, m;
n = 4;
m = -9;
soma(n, m);
printf("%d\n",res);
system("pause");
return 0;
}
#include <stdio.h>
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros por referência (com contexto de ação - não há
retorno de valor)
VisuAlg: procedimento soma (x,y: inteiro; var result: inteiro)
inicio
result <- x + y
fimprocedimento 
No programa principal deve haver os seguintes comandos:
n <- 4
m <- -9
soma(n,m,result)
escreva(result)
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros por referência (com contexto de ação - nãohá
retorno de valor)
É NECESSÁRIO INTRODUZIR O CONCEITO DE “PONTEIROS” PARA 
UTILIZAR PASSAGEM DE PARÂMETROS POR REFERÊNCIA NA LINGUAGEM 
C.
“O C só faz chamadas por valor. Isto é bom quando queremos usar os
parâmetros formais à vontade dentro da função, sem termos que nos
preocupar em estar alterando os valores dos parâmetros que foram passados
para a função. Mas isto também pode ser ruim às vezes, porque podemos
querer mudar os valores dos parâmetros fora da função também. O C++ tem
um recurso que permite ao programador fazer chamadas por referência. Há
entretanto, no C, um recurso de programação que podemos usar para simular
uma chamada por referência.”
C: 
Fonte:
http://mtm.ufsc.br/~azeredo/cursoC/aulas/c770.html
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros por referência (com contexto de ação - não há
retorno de valor)
“Quando queremos alterar as variáveis que são passadas para uma função,
nós podemos declarar seus parâmetros formais como sendo ponteiros. Os
ponteiros são a "referência" que precisamos para poder alterar a variável fora
da função. O único inconveniente é que, quando usarmos a função, teremos
de lembrar de colocar um & na frente das variáveis que estivermos passando
para a função. Veja um exemplo:”
C: 
Fonte:
http://mtm.ufsc.br/~azeredo/cursoC/aulas/c770.html
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros por referência (com contexto de ação - não há
retorno de valor)
#include <stdio.h>
void Swap (int *a,int *b);
int main (void)
{
int num1,num2;
num1=100;
num2=200;
Swap (&num1,&num2);
printf ("\n\nEles agora valem %d e %d\n",num1,num2);
system("pause");
return 0;
}
void Swap (int *a,int *b)
{
int temp;
temp=*a;
*a=*b;
*b=temp;
}
C: 
Fonte:
http://mtm.ufsc.br/~azeredo/cursoC/aulas/c770.html
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros por referência (com contexto de ação - não há
retorno de valor)
“Não é muito difícil. O que está acontecendo é que passamos para a função Swap o
endereço das variáveis num1 e num2. Estes endereços são copiados nos ponteiros a e b.
Através do operador * estamos acessando o conteúdo apontado pelos ponteiros e
modificando-o. Mas, quem é este conteúdo? Nada mais que os valores armazenados em
num1 e num2, que, portanto, estão sendo modificados!
Espere um momento... será que nós já não vimos esta estória de chamar uma função com
as variáveis precedidas de &? Já! É assim que nós chamamos a função scanf(). Mas
porquê? Vamos pensar um pouco. A função scanf() usa chamada por referência porque ela
precisa alterar as variáveis que passamos para ela! Não é para isto mesmo que ela é feita?
Ela lê variáveis para nós e portanto precisa alterar seus valores. Por isto passamos para a
função o endereço da variável a ser modificada! “
C: 
Fonte:
http://mtm.ufsc.br/~azeredo/cursoC/aulas/c770.html
Declaração e manipulação de modularização de algoritmos – procedimento 
sem passagem de parâmetros (com contexto de resultado - funções - há 
retorno de valor)
VisuAlg: funcao soma: inteiro
var aux: inteiro
inicio
// n, m e res são variáveis globais
aux <- n + m
retorne aux
fimfuncao
No programa principal deve haver os seguintes comandos:
n <- 4
m <- -9
res <- soma
escreva(res)
Declaração e manipulação de modularização de algoritmos – procedimento 
sem passagem de parâmetros (com contexto de resultado - funções - há 
retorno de valor)
int soma(void);
int soma(void){
int aux;
// n, m e res são variáveis globais
aux = n + m;
return aux;
}
No programa principal deve haver os seguintes comandos:
n = 4;
m = -9;
res = soma;
printf("%d\n", res);
system("pause");
C: 
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros (com contexto de resultado - funções - há
retorno de valor)
VisuAlg: funcao soma (x,y: inteiro): inteiro
inicio
retorne x + y
fimfuncao 
No programa principal deve haver os seguintes comandos:
n <- 4
m <- -9
res <- soma(n,m)
escreva(res)
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros (com contexto de resultado - funções - há
retorno de valor)
int soma(int x, int y);
int soma(int x,int y){
return x + y;
}
No programa principal deve haver os seguintes comandos:
n = 4;
m = -9;
res = soma(n,m);
printf("%d\n", res);
system("pause");
C: 
C: 
#include <stdio.h>
int mult (int x, int y);
int main(void)
{
int x;
int y;
printf( “Por favor, insira dois números para serem 
multiplicados: " );
scanf( "%d", &x );
scanf( "%d", &y );
printf( “O produto dos seus dois números é: %d\n", mult( x, 
y ) );
system("pause");
return 0;
}
int mult (int x, int y)
{
return x * y;
}
Fonte: https://www.cprogramming.com/tutorial/c/lesson4.html
Declaração e manipulação de modularização de algoritmos – procedimento 
com passagem de parâmetros (com contexto de resultado - funções - há
retorno de valor)
Recursão
funcao fatorial (v: inteiro): inteiro
inicio
se v <= 2 entao
retorne v
senao
retorne v * fatorial(v-1)
fimse
fimfuncao
VisuAlg: 
Recursão
int fatorial (int v)
{
if (v <= 2)
{
return v;
}
else
{
return v * fatorial(v-1);
}
}
C: 
Referências
• FORBELLONE, A. L. V.; EBERSPÄCHER, H. F.. Lógica de programação: a construção 
de algoritmos e estruturas de dados. 3. ed. São Paulo: Pearson Prentice Hall, 
2005. 197 p.
• KERNIGHAN, B.W.; RITCHIE, D.M.. The C Programming Language. 2 ed. Upper 
Saddle River: Prentice Hall, 1988. 263 p.
• KING. K.N.. C Programming: a modern approach. 2. ed. New York: W.W. Norton, 
2008. 832 p.
• Manual do Visualg 3.0. Disponível em: 
<https://manual.visualg3.com.br/doku.php?id=manual>.
Acesso em: 03 de set. 2017.