UNIVERSIDADE PAULISTA

DANIEL KHALIL SILVA E SOUSA

Linguagem e técnicas de programação

Linguagem C

MANAUS

2017
 DANIEL KHALIL SILVA E SOUSA

Linguagem e técnicas de programação

Linguagem C

Trabalho solicitado para obtenção de nota

parcial na disciplina de Linguagem e técnicas
de programação ministrada pelo professor
Rildo Nogueira à Universidade Paulista – UNIP.

MANAUS

2017
 ABSTRACT

Technology advances every time, and increasingly new products and quality systems
and it offers services that provide its users with better quality technology.

To understand how language C works in the field of development, we must know

from the beginning of its creation, to its functions and uses to develop, create and
create new technologies and concepts.

Be what is best known as the goal of this knowledge of functionality and important
steps to continue programming in C and be a good developer or programming
language.

Keywords: Knowledge, functionality, develop.

 RESUMO

A tecnologia avança cada vez mais, e cada dia vemos novos tipos de produtos e
sistemas de qualidade e que oferecem serviços que proporcionam a seus usuários
tecnologia de melhor qualidade.

Para entendermos como a linguagem C funciona no campo de desenvolvimento,

devemos conhecer desde os primórdios de sua criação, até suas funções e
utilizações para desenvolver, criar, e construir novas tecnologias e conceitos.

O trabalho a ser apresentado tem como objetivo trazer esse conhecimento da

funcionalidade e dos passos importantes a se seguir para se programar em C e ser
um bom desenvolvedor nesta linguagem de programação.

Palavras Chave: conhecimento, funcionalidade, desenvolver.

 SUMÁRIO

1 INTRODUÇÃO ....................................................................................................... 06

2 DESENVOLVIMENTO ........................................................................................... 07

2.1 Histórico da Linguagem C.............................................................................................07

2.2 C ANSI..........................................................................................................................07
2.3 Principais características..............................................................................................08
2.4 Cabeçalho de funções..................................................................................................08
2.5 IDE................................................................................................................................09
2.6 Compiladores................................................................................................................10
2.7 Processo de Compilação..............................................................................................10
2.7.1 – Análise Léxica.................................................................................................10
2.7.2 – Análise Sintática..............................................................................................11
2.7.3 – Análise Semântica...........................................................................................11
2.7.4 – Geração de código Intermediário....................................................................11
2.7.5 – Otimização de código......................................................................................11
2.7.6 – Geração de código final..................................................................................11
2.8 Processo básico de uma fonte em C: Criado por IDE..................................................11
2.9 Variáveis.......................................................................................................................12
2.10 Tipos de Variáveis......................................................................................................13
2.11 Comando de entrada de dados..................................................................................13
2.11.1 – A função scanf...............................................................................................13
2.12 Comando de saída de dados......................................................................................14
2.12.1 – A função printf...............................................................................................14
2.13 Laços..........................................................................................................................14
2.13.1 Tipos de Laços.................................................................................................15
2.13.1.1 – O laço FOR.....................................................................................15
2.13.1.2 – O laço WHILE.................................................................................15
2.13.1.3 – O laço DO-WHILE..........................................................................16
2.14 Estrutura de Tomada de decisões..............................................................................16
2.14.1 Tipos de estruturas condicionais.....................................................................17
2.14.1.1 – IF/ELSE .........................................................................................17
2.14.1.2 – SWITCH/CASE...............................................................................17
2.14.2 Finalizados de comandos................................................................................18
2.14.3 Finalizador de linhas.......................................................................................18
2.15 Funções em C............................................................................................................19
2.15.1 – Variável Local...............................................................................................19
2.15.2 – Variável Global.............................................................................................19
2.16 Partes fundamentais de uma codificação...................................................................20
2.17 Processos de organização e codificação...................................................................21
2.18 Funções e procedimentos..........................................................................................22

4 CONCLUSÃO ........................................................................................................ 25

5 REFERÊNCIAS BIBLIOGRÁFICAS ...................................................................... 26

 INTRODUÇÃO

Com a linguagem C é possível criar, manipular, e programar diversos tipos de

aplicativos e desenvolver diversas funções. A linguagem C, é uma das linguagens de
programação mais famosas e é a segunda mais utilizada do mundo segundo o
Spectrum Ranking de 2017.

Desde sua criação e derivação da linguagem BCPL, C era uma linguagem com
diversas possibilidades, e por muito anos C foi um padrão exclusivo do sistema
UNIX sendo limitado a outros sistemas, até serem criadas muitas implementações
para que C fosse utilizado em outros tipos de microcomputadores da época.

Por sua facilidade, portabilidade e por possuir inúmeras funções de criação e

desenvolvimento, a linguagem C conquistou mercado, cresceu e hoje em dia é
considerada uma das melhores linguagens de médio nível para se programar.

Este trabalho acadêmico traz o conhecimento sobre a linguagem C e C ANSI

demonstrando sua utilidade, processos e comandos e como ela funciona de forma
abrangente na área de programação e desenvolvimento de sistemas.

6
 DESENVOLVIMENTO

2.1 - Histórico da Linguagem C

A linguagem C foi inventada e implementada por Dennis Ritchie em um DEC

PDP-11 que utilizava o sistema operacional UNIX. C é o resultado de um processo
que começou com uma linguagem mais antiga, chamada BCPL, que ainda está em
uso nos dias atuais. Mas foi a linguagem B que levou ao desenvolvimento da
linguagem C em 1970.

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, mas em 1978 Brian Kernighan e Dennis Ritchie
lançam o livro The C Programming Language 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".

Por muitos anos, o padrão para C foi a versão fornecida com o sistema
operacional UNIX versão 5, mas com a popularidade dos microcomputadores, um
grande número de implementações de C foi criado, e por um milagre, os códigos-
fontes tiveram compatibilidade com as implementações e foram compatíveis.

Por não existir um padrão para C, havia discrepâncias. E para remediar essa
situação, ANSI (American National Standards Institute) estabeleceu um comitê para
criar esse padrão e definir a linguagem C, foi criado o padrão ANSI que foi
implementado em quase todos os principais compiladores.

C é uma linguagem imperativa e procedural, para implementação de

sistemas. Seus pontos de design foram para ele ser compilado, fornecendo acesso
de baixo nível à 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.

2.2 - C ANSI

A linguagem C começou a substituir a linguagem BASIC como a linguagem

de programação de microcomputadores mais usada durante os finais da década de
1970. 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
projeto onde se adicionavam extras para programação orientada por objetos à
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
7
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.

2.3 - Principais Características

C foi criada com o objetivo 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 é
realizar as características complexas da linguagem.
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

2.4 - Cabeçalho de funções

Arquivos-cabeçalhos são aqueles que temos mandamos o compilador incluir

no início de nossos exemplos e que sempre terminam em .h. A extensão .h vem
de header (cabeçalho em inglês).

Estes arquivos, na verdade, não possuem os códigos completos das funções.

Eles possuem apenas protótipos de funções. O compilador lê estes protótipos e
baseado nas informações lá contida gera o código correto.

8
 O corpo das funções cujos protótipos estão no arquivo-cabeçalho, no caso
das funções do próprio C, já estão compiladas e normalmente são incluídas no
programa no instante em que forem linkados. Este é o instante em que todas as
referências a funções cujos códigos não estão nos nossos arquivos fontes são
resolvidas, buscando este código nos arquivos de bibliotecas.

Se você criar algumas funções que queira aproveitar em vários programas

futuros, ou módulos de programas, você pode escrever arquivos-cabeçalhos e incluí-
los também.

Os arquivos .h são uma espécie de 'intermediário', entre seu programa e os

módulos.
Nos cabeçalhos é onde explicamos o que cada função definida nos módulos faz, ou
seja, o header é uma interface de comunicação.

Os principais cabeçalhos usados na biblioteca são:

 stdio.h – usado para padrão de entrada e saída

 stdlib.h – usado para biblioteca padrão
 conio.h – usado para console de entrada e saída
 math.h – usado para funções matemáticas
 string.h – usado para fornecer funções macro e definições da
biblioteca

Também podem ser utilizados cabeçalhos criados e definidos pelo usuário

utilizando as funções definidas pelo próprio usuário.

2.5 - IDE

IDE, do inglês Integrated Development Environment ou Ambiente de

Desenvolvimento Integrado, é um programa de computador que reúne
características e ferramentas de apoio ao desenvolvimento de software com o
objetivo de agilizar este processo.[1][2]
Geralmente os IDEs facilitam a técnica de RAD (de Rapid Application
Development, ou "Desenvolvimento Rápido de Aplicativos"), que visa a maior
produtividade dos desenvolvedores.
As características e ferramentas mais comuns encontradas nos IDEs são:

 Editor - edita o código-fonte do programa escrito na(s) linguagem(ns)

suportada(s) pela IDE;
 Compilador (compiler) - compila o código-fonte do programa, editado
em uma linguagem específica e a transforma em linguagem de máquina;
 Linker - liga (linka) os vários "pedaços" de código-fonte, compilados
em linguagem de máquina, em um programa executável que pode ser executado
em um computador ou outro dispositivo computacional;

 Depurador (debugger) - auxilia no processo de encontrar e

corrigir defeitos no código-fonte do programa, na tentativa de aprimorar
a qualidade de software;
9
  Modelagem (modeling) - criação do modelo
de classes, objetos, interfaces, associações e interações dos artefatos
envolvidos no software com o objetivo de solucionar as necessidades-alvo do
software final;

 Geração de código - característica mais explorada em Ferramentas

CASE, a geração de código também é encontrada em IDEs, contudo com um
escopo mais direcionado a templates de código comumente utilizados para
solucionar problemas rotineiros. Todavia, em conjunto com ferramentas de
modelagem, a geração pode gerar praticamente todo o código-fonte do programa
com base no modelo proposto, tornando muito mais rápido o processo de
desenvolvimento e distribuição do software;

 Distribuição (deploy) - auxilia no processo de criação do instalador

do software, ou outra forma de distribuição, seja discos ou via internet;

 Testes Automatizados (automated tests) - realiza testes no software

de forma automatizada, com base em scripts ou programas de testes
previamente especificados, gerando um relatório, assim auxiliando na análise do
impacto das alterações no código-fonte. Ferramentas deste tipo mais comuns no
mercado são chamadas robôs de testes;

 Refatoração (refactoring) - consiste na melhoria constante do código-

fonte do software, seja na construção de código mais otimizado, mais limpo e/ou
com melhor entendimento pelos envolvidos no desenvolvimento do software. A
refatoração, em conjunto com os testes automatizados, é uma poderosa
ferramenta no processo de erradicação de "bugs", tendo em vista que os testes
"garantem" o mesmo comportamento externo do software ou da característica
sendo reconstruída.

2.6 - Compiladores

Um compilador é um programa de sistema que traduz um programa descrito

em uma linguagem de alto nível para um programa equivalente em código de
máquina para um processador. Em geral, um compilador não produz diretamente o
código de máquina, mas sim um programa em linguagem
simbólica (assembly) semanticamente equivalente ao programa em linguagem de
alto nível. O programa em linguagem simbólica é então traduzido para o programa
em linguagem de máquina através de montadores.

2.7 -Processo de compilação

2.7.1 - Análise Léxica

A função do analisador léxico, também denominado scanner, é ler o código fonte,

caracter a caracter, buscando a separação e identificação dos elementos componentes do
programa fonte, denominados símbolos léxicos ou tokens. É também de responsabilidade

10
desta fase a eliminação de elementos "decorativos" do programa, tais como espaços em
branco, marcas de formatação de texto e comentários.

2.7.2 - Análise Sintática

É o processo de se determinar se uma cadeia de símbolos léxicos pode ser gerada por
uma gramática. O analisador sintático é o cerne do compilador, responsável por verificar se
os símbolos contidos no programa fonte formam um programa válido, ou não.

2.7.3 - Análise Semântica

As análises léxicas e sintáticas não estão preocupadas com o significado ou semântica

dos programas que elas processam. O papel do analisador semântico é prover métodos
pelos quais as estruturas construídas pelo analisador sintático possam ser avaliadas ou
executadas. É papel do analisador semântico assegurar que todas as regras sensíveis ao
contexto da linguagem estejam analisadas e verificadas quanto à sua validade.

2.7.4 - Geração de código intermediário

Ocorre a transformação da árvore sintática em uma representação intermediária do

código fonte. Esta linguagem intermediária é mais próxima da linguagem objeto do que o
código fonte, mas ainda permite uma manipulação mais fácil do que se código assembly ou
código de máquina fosse utilizado.

2.7.5 -Otimização de códigos

A Otimização de código é a estratégia de examinar o código intermediário, produzido

durante a fase de geração de código com objetivo de produzir, através de algumas técnicas,
um código que execute com bastante eficiência.

2.7.6 - Geração de código final

A fase de geração de código final é a última fase da compilação. A geração de um

bom código objeto é difícil devido aos detalhes particulares das máquinas para os quais o
código é gerado. Contudo, é uma fase importante, pois uma boa geração de código pode ser,
por exemplo, duas vezes mais rápida que um algoritmo de geração de código ineficiente.
Nem todas as técnicas de optimização são independentes da arquitetura da máquina-alvo.
Optimizações dependentes da máquina necessitam de informações tais como os limites e os
recursos especiais da máquina-alvo a fim de produzir um código mais compacto e eficiente.

2.8 -Processo básico de uma fonte em C: Criado por IDE

Um dos processos mais básicos em C, é criar uma função na qual se possa

digitar o nome e idade de acordo com as variáveis nome e idade e definir se o
usuário é criança, adolescente ou adulto.

11
Exemplo de processo criado pela IDE DevC++:
#include <stdio.h>
#include <stdlib.h>

char nome[];
int idade;

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

{

printf(“digite seu nome:\n”);

gets(nome);
printf(“digite sua idade:\n”);
scanf(“%d”,&idade);

printf(“nome = %s\n”,nome);
printf(“idade = %d\n”,idade);

if(idade<13)
{
printf(“Voce e crianca!\n”);
}

else if(idade>13 && <21)

{
printf(“Voce e adolescente!\n”);
}

else if(idade>=21)
{
printf(“Voce e adulto!\n);
}

system(“PAUSE”);
return 0;
}

2.9 - Variáveis

Variável é uma posição que recebe o nome de memória, que é usada para
guardar um valor que pode ser modificado pelo programa sendo declarada em três
lugares básicos: dentro das funções, na definição de parâmetros, parâmetros
formais e variáveis globais, respectivamente.

As variáveis locais são declaradas dentro de uma função. Podem se referir a

variáveis automática, pelo fato de que em C pode-se usar palavra-chave auto para
declará-las. Elas existem apenas enquanto o bloco do código em que foram
declaradas está sendo executado. Ou seja, ela é criada na entrada de seu bloco e
destruída na saída.

Uma das principais vantagens da declaração de uma variável local dentro do

bloco condicional é que a memória para ela só será alocada se necessário. O motivo
pelo qual isso ocorre é por que variáveis locais não existirão até que um
determinado bloco em que elas são declaradas seja inicializado.
12
 Deve-se iniciar as variáveis locais no início do bloco em que elas são
definidas, antes de qualquer comando do programa.

Exemplo:
#include <stdio.h>
#include <stdlib.h>
Void f(void)
{
int t;

scanf(“%d”,&t);

if(t == 1)
{

Char s[80]; /* criado apenas para entrada deste bloco */

Print(“entre com o nome:”);

Gets(s); /* faz alguma coisa*/

}
}

getch();
return(0);
}

2.10 - Tipos de Variáveis

Os tipos mais comuns de variáveis são:

 INTEIRO: Armazena valores numéricos inteiros.

 REAL: Armazena números com casas decimais, são variáveis de ponto
flutuante.
 CARACTERE: capaz de representar um caractere ou um conjunto de
caracteres (letras, dígitos ou símbolos).
 BOOLEANA: representa valores lógicos. Apenas podem conter um de dois
valores que são palavras reservadas: true e false.
 CHAR: armazena caracteres.
 FLOAT: armazena números com ponto flutuante (reais) com precisão
simples.
 DOUBLE: armazena número com ponto, com precisão dupla, ou seja,
normalmente possui o dobro da capacidade de uma variável do tipo float.

2.11 - Comando de entrada de dados

2.11.1 - A função scanf

A função scanf é utilizada para fazer a leitura de dados formatados via

teclado.

13
Sintaxe:

scanf(“expressão de controle”, lista de argumentos);

Exemplo:

scanf(“%f”, &salario);

Explicação: este comando efetua uma leitura do teclado onde é esperada

uma variável float (indicada por “%f”). O valor lido será armazenado no endereço da
variável salário.

Na lista de argumentos devemos indicar os endereços das variáveis. Para

fazer isso adicionamos o símbolo “&” como prefixo na frente do nome da variável.

2.12 - Comando de saída de dados

2.12.1 - A função printf

A função printf é o comando usado para exibir valores na tela.

Sintaxe Básica

printf(“Mensagem a ser escrita na tela”);

Também é possível mostrar texto e valores de variáveis usando argumentos.

Sintaxe:

printf(“Mensagem a ser escrita na tela”, lista de argumentos);

Exemplo de mensagem que inclui o valor de uma variável:

printf(“Total a pagar: R$ %f”, total);

onde:

%f representa o local onde será escrita uma variável float

total é a variável float que será mostrada na posição marcada por %f.

2.13 – Laços

Em C, em todas as outras linguagens modernas de programação, comandos

de iteração (também chamados laços) permitem que um conjunto de instruções seja
executado até que ocorra uma certa condição. Essa condição pode ser pre-definida
(como no laço for) ou com final em aberto (como nos laços while e do-while).

14
2.13.1 - Tipos de laços

2.13.1.1 - O laço FOR

O laço for é um laço muito utilizado na linguagem C fornecendo flexibilidade e

capacidades de permitir diversas variações. É muito útil quando se sabe de antemão
quantas vezes a repetição deverá ser executada.

A forma geral do comando for é:

for(inicialização; condição; incremento) comando;.

Em pseudocódigo o laço for da linguagem C é equivalente ao comando

“Para”. Este laço utiliza uma variável para controlar a contagem do loop (Laço), bem
como seu incremento.

Trata-se de um comando bem enxuto, já que própria estrutura faz a

inicialização, incremento e encerramento do laço.

Exemplo: Programa usando Loop em C:

#include <stdio.h>
#include <conio.h>
int main(void)
{
int contador; //variável de controle do loop
for(contador = 1; contador <= 10; contador++)
{
printf("%d ", Contador);
}
getch();
return(0);
}

2.13.1.2 - O laço WHILE

O segundo laço disponível e utilizado na linguagem C é o Laço White.

Executa a repetição de um bloco de instruções enquanto uma condição for
verdadeira. Enquanto a condição for verdadeira, ela seguirá instruções. Se falsa,
será desviada para fora do laço.

Sua forma geral de utilização é:

while(condição)comando;

Exemplo:

15
#include <stdio.h>
#include <conio.h>
int main(void)
{
int contador = 1; //declarando e inicializando a variável de controle

while (contador <= 10) // Testando a condição

{
printf("%d ", contador); //Executando um comando dentro do laço

contador++; //atualizando a variável de controle

}

getch();
return 0;
}

2.13.1.3 - O laço DO-WHILE

Ao contrário dos laços For e While que testam as condições de laços no

início, o laço do-while verifica a condição ao final do laço. O laço do-while, assim
como o while é uma estrutura de controle de fluxo que permite que um conjunto de
instruções seja executado enquanto uma condição estiver satisfeita.

Sua forma geral de utilização é:

Do
{
comando;
} while(condição);

Exemplo:
#include<stdio.h>
int main(void)
{
float nota1=0,nota2=0,media=0;
int resp;
do
{
printf("Digite a primeira nota: ");
scanf("%f",&nota1);
printf("Digite a segunda nota: ");
scanf("%f",&nota2);

media = (nota1 + nota2)/2;

printf("Media do aluno = %f\n",media);

printf("Digite 1 para continuar ou 2 para sair\n");

scanf("%d", &resp);
}while (resp==1);

return 0;
}

16
2.14 - Estrutura de tomada de decisões

C suporta dois tipos de comandos de seleção if e switch. Além disso, o

perador ? é uma alternativa em certas circunstâncias.

2.14.1 - Tipos de estruturas condicionais

2.14.1.1 - IF/ ELSE

A forma geral da sentença if é

if(expressão) comando;

else comando;

onde comando pode ser o único comando, um bloco de comandos ou nada

(no caso de comandos vazios).

Se a expressão é verdadeira (diferente de 0), o comando ou bloco que forma

o corpo do if é executado; caso contrário, o comando ou bloco é o corpo else (se
existir) é executado.

O comando condicional o if deve produzir um resultado escalar. Um escalar é

um inteiro, um caractere ou tipo de ponto flutuante.

2.14.1.2 – SWITCH/CASE

C possui u comando interno de seleção múltipla, switch, que testa

sucessivamente o valor de uma expressão contra uma lista de constantes inteiras ou
de caractere. Quando o valor coincide, os comandos associados àquela constante
são executados. A forma geral do comando switch é:

switch(expressão) {
case constante1:
sequência de comandos
break;
case constante2:
sequência de comandos
break;
case constante1:
sequência de comandos
break;
.
.

default:
sequência de comandos
}

17
 O valor expressão é testado, na ordem, contra os valores das constantes
especificadas nos comandos case. Quando uma coincidência for encontrada, a
sequência de comandos associada àquele case será executada até que o comando
break ou fim do comando switch seja alcançado. O comando default é
executado se nenhuma coincidência for detectada. O default é opcional e, se não
estiver presente, nenhuma ação será realizada se todos os testes falharem.

2.14.2 - Finalizador de comandos

As chaves ({ }) são utilizadas para se iniciar e finalizar comandos. E também

são utilizados para iniciar e finalizar linhas de comando dentro de um comando para
que possam ser lidos, compilados e executados.

Exemplo:

{ /* iniciar linha de comandos*/

If() { /* iniciar comando*/

comandos();

} /* finalizar comando*/

} /* finalizador de linhas de comandos*/

Execução.

2.14.3 - Finalizador de linhas

Para se finalizar as linhas de um comando, utiliza-se o ponto e vírgula (;).

Comandos como de entrada e saída, limpador de buffer do teclado, comandos
dentro de comandos recebem o ponto e vírgula para que seja finalizado a linha de
um comando.

Exemplos:

print( );

getchar ();

scanf(“%d”,&link);

Exemplo de comandos dentro de comandos:

if{

comando( );

18
2.15 - Funções em C

2.15. 1 - Variável Local

Variáveis que são declaradas dentro de uma função recebe o nome de

variáveis locais.

Variáveis Locais existem apenas enquanto o bloco de código em que foram

declaradas está sendo executado. Ou seja, uma variável local é criada na entrada
de seu bloco e destruída na saída.

O bloco de códigos mais comum em que as variáveis locais foram declaradas

é a função.

Exemplo:
void func1(void)
{
int x;
x = 10
}
void func2(void)
{
int x;
x = -199;
}

A linguagem C contém a palavra-chave declarada auto, que pode ser utilizada

para declarar variáveis locais, mas quase nunca é usada.

A principal vantagem de declarar uma variável local dentro de um bloco

condicional é que a memória para ela só será alocada se necessário. Isso acontece
por que variáveis locais não existirão até que o bloco em que elas são declaradas
seja iniciado.

2.15.2 - Variável Global

As variáveis globais ao contrário das locais, são reconhecidas pelo programa

inteiro e podem ser usadas por qualquer pedaço de código.

Elas também guardam seus valores durante toda a execução do programa.

Você cria variáveis globais declarando-as em qualquer lugar anterior ao seu

primeiro uso.

A melhor forma de declarar uma variável global é no início do programa.

19
Exemplo:
#include<stdio.h>
int count; /* count é global */
void func1(void);
void func2(void);
void man(void)
{
count = 100
func1();
}
void fun1(void)
{
int temp;

temp = count;
func2();
printf("count é %d", count); /* imprimirá 100 */
}

void fun2(void)
{
int count;
for(count=1; count<10; count++)
putchar('.');
}

Em outras palavras, é uma variável que pode ser usada para qualquer função
de código.

2.16 - Partes fundamentais de uma codificação

Existem diversas partes que são fundamentais em uma codificação são

diversas, algumas delas temos:

 Cabeçalhos;
 Variáveis;
 Comandos de entrada e saída de funções;
 Finalizadores de comandos;
 Uso de bibliotecas para codificação;
 Inicializadores de comandos;
 Compilar códigos;
 Execução e teste de codificação;
 Definição de variáveis;
 Uso de IDEs para codificação;
 Análise verificação de comandos;
 Constantes;
 Operadores;
 Expressões;
 Parênteses e colchetes;
 Funções;
 Instruções;
20
  Identificadores;
 Ponteiros;

São exemplos de partes fundamentais para se ter uma boa codificação.

2.17 - Processo de organização e codificação

A codificação, para que seja bem compreendida pelo compilador e até mesmo
do programador em C, deve estar organizada da forma que se possa distinguir
variáveis de comandos declarados dentro das linhas, onde eles se iniciam e
finalizam, e onde se começa a codificação e onde termina pronto para se executar,
onde ficam os cabeçalhos e bibliotecas com que irá trabalhar no código e dentre
outras funções que devem estar organizadas.

Temos um pequeno exemplo de codificação organizada, onde vão conter os

códigos e variáveis, e ao lado os comentários em negrito para que se entenda como
é feita a organização dos códigos:

#include <stdio.h> /*cabeçalho e padrão de E/S */

#include <stdlib.h> /*cabeçalho e biblioteca padrão*/

char nome[]; /*variável do tipo char – nome*/

int idade; /*variável do tipo inteiro – idade*/

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

{ /*inicializador de linhas de comando*/

printf(“digite seu nome:\n”); /*Leitura de comando */

gets(nome); /* entrar com a variável nome */
printf(“digite sua idade:\n”); /*Leitura de comando */
scanf(“%d”,&idade); /* entrar com número inteiro variável idade */

printf(“nome = %s\n”,nome); /*Leitura de comando, variável nome */

printf(“idade = %d\n”,idade); /*Leitura de comando, variável idade */

if(idade<13) /*condição se idade for menor que 13*/

{ /*inicializador de linha de condição*/

printf(“Voce e crianca!\n”); /*Leitura de condição */

} /*finalizador de linha de condição*/

else if(idade>13 && <21) /*condição idade maior que 13, menor que 21*/
{ /*inicializador de linha de condição*/

printf(“Voce e adolescente!\n”); /*Leitura de condição */

}

else if(idade>=21) /*condição se idade for maior que 21*/

{
printf(“Voce e adulto!\n); /*Leitura de condição */

} /*finalizador de linha de condição*/

21
 system(“PAUSE”); /* terminar execução */
return 0; /* retornar valor a 0 */
} /* Finalizar codificação*/

2.18 - Funções e procedimentos

Em C não existe uma distinção entre funções e sub-rotinas. Ou seja, todas as

sub-rotinas, do ponto de vista de algoritmos, podem ser tratadas como funções que
não retornam nenhum valor.

Formato de declaração de funções:

Tipo de
retorno identificador_da_função
(tipo1 param1, tipo2 param2,..., tipoN paramN)
{

/* corpo da função */

return valor de retorno;

} /* fim da função */

Tipo de retorno especifica o tipo do valor que será retornado para quem
chamou a função. Quando o tipo de retorno for void isto significa que se trata de
uma função que se comporta como uma subrotina; ou seja, a função não necessita
retornar nenhum valor, apenas ser chamada.

Exemplos de tipos de retorno nos cabeçalhos das funções:

int func1(...) /* retorna um valor inteiro */

void func2(...) /* não retorna nenhum valor. Comporta-se como
subrotina */

O comando return é utilizado para realizar o retorno da função; este pode ser
utilizado em qualquer ponto da função que se deseje finalizar a sua execução e
retornar o valor (se a função retornar algum valor) para quem a chamou.

Valor de retorno é o valor a ser efetivamente retornado e pode ser tanto uma
variável como uma constante; nos casos em que a função não retorna nenhum valor
o comando return deve ser utilizado sozinho ou pode-se simplesmente omiti-lo, o
que fará com que a função retorne automaticamente ao seu final.

Exemplos de uso de return:

return 0; /* retorna o valor constante 0 */

return var; /* retorna o valor da variável ‘var’ */
return; /* não retorna valor. É usado para funções com
retorno do tipo void */

Os parâmetros param1 a paramN identificam os parâmetros que se deseja

passar para a função. Cada um destes parâmetros passa a ser uma variável local da
22
função de tipo tipo1 a tipoN e é inicializado com o valor que foi passado para si no
momento da chamada da função. Funções que não recebem nenhum valor como
parâmetro devem ser declaradas com a palavra void entre os parênteses.

Exemplos de declarações de parâmetros no cabeçalho das funções:

/* dois parâmetros, um int e um char. O ... se refere a um tipo de

retorno qualquer */
... Func1(int var, char var2)
{
}
... Func2 (void) /* não recebe nenhum parâmetro */
{
}

Exemplo de função e programa em C que a chama:

int func1 (char carac, int inteiro, float flutuante) /* declaracão da

função */
{
/* pode-se declarar outras variáveis aqui dentro, como em um trecho
normal de programa estas variáveis são locais da função */
int outra;

/* uso das variáveis recebidas como parâmetro */

printf(“%c”, carac); printf(“%f”, flutuante);
scanf(“%d”, &outra);

printf(“%d”, inteiro + outra);

return outra; /* retorna o valor da variável ‘outra’ */

} /* fim da função */

void main (void) /* programa principal */

{
char c1;
float f;
int resultado;
int inteiro;
/*esta variável ‘inteiro’ existe no escopo da função ‘main’, logo não
tem nada a ver com a variável ‘inteiro’ que é criada na função ‘func1’ no
momento da passagem dos parâmetros */

/* lê um número inteiro, um caracter e um float */

scanf(“%d, %c, %f”, &inteiro, &c1, &f);

/* chama a função ‘func1’ com os parâmetros na ordem correta */

resultado = func1(c1, inteiro, f);
printf(“%d”, resultado); /* imprime resultado da função */

23
 Procedimentos são estruturas que agrupam um conjunto de comando que são
executados quando o procedimento é chamado.

void nome_do_procedimento (<tipo> parametro1, <tipo> parametro2, ...,

<tipo> parametroN)
{
<corpo do procedimento>
}

Exemplo do procedimento:

void imprime_dobro(int x)
{
printf("Dobro de x: %d", 2*x);
}

Para invocarmos um procedimento, devemos utilizá-lo como qualquer outro

comando:

procedimento(parâmetros);

Compare a diferença de invocação de uma função:

resultado = função(parâmetros);

int x, y, resultado;

void soma()
{
resultado = x + y;
}

int main()
{
x=3;
y=5;
soma();
printf("%d\n", resultado);

24
 CONCLUSÃO

Introduzir conhecimento a linguagem C e suas diversas funções é bastante

importante para que se aprenda como é realizada a área de programação em
sistemas.

A linguagem C possui diversas funções na qual um programador pode

trabalhar. E por isso, ela é ótima para se desenvolver sistemas, bancos de dados,
programas, desenvolver habilidades, trabalhar os conhecimentos em programação e
suas funções. Além de ser de fácil utilização, case sensitive e apresentar se os
comandos desenvolvidos estão corretos, ter bastante portabilidade e ser utilizada em
quase todos os tipos de sistemas de computadores.

Com todas as informações sobre este tipo de linguagem, pode-se concluir

que a linguagem C, desde o início de sua criação trouxe para o ramo da
programação muita utilidade por ser uma linguagem de inúmeras funções, e que um
desenvolvedor pode utilizar para criar diversos tipos programas e utilizá-la tanto para
o desenvolvimento pessoal quanto profissional.

25
 REFERÊNCIAS BIBLIOGRAFICAS

SCHILDT, Herbert. C Completo e Total. 3° Ed. Editora McGraw-Hill. São Paulo

1995.

Linguagem C, < http://linguagemc.com >, acesso em 25/09/2017.

USP C,< http://stoa.usp.br/ccpp/weblog/7333.html > acesso em 25/09/2017.

C PROGRESSIVO< http://www.cprogressivo.net > acesso em 25/09/2017.

SLIDESHARE< https://pt.slideshare.net/adrianots/estrutura-de-dados-aula-42,acess
> oem 25/09/2017.

WIKIPEDIA <
https://pt.wikipedia.org/wiki/C_(linguagem_de_programa%C3%A7%C3%A3o) >
acesso em 25/09/2017.

26