Apostila C++, Notas de estudo de Informática

Baixe Apostila C++ e outras Notas de estudo em PDF para Informática, somente na Docsity!

Bacharelado em Sistemas de Informação

Algoritmos

Prof. Ms. Antonio Marcos SELMINI

Apostila de

Algoritmos / Linguagem C

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

Prefácio

Este material é o resultado das notas de aulas das disciplinas Algoritmos e

Estruturas de Dados.

O principal objetivo deste material é auxiliar os alunos na disciplina de

Algoritmos ministrada na Faculdade de Informática e Administração Paulista

(FIAP). Vale destacar também que este material não substitui em hipótese

alguma os livros indicados como bibliografia básica, pois deverão ser

consultados para uma melhor formação profissional.

Prof. Ms. Antonio Marcos Selmini

• Capítulo 1 - Introdução à Microinformática Índice
  • 1.1 Introdução
  • 1.2 Precursores do Computador.................................................................................
  • 1.3 Gerações dos Computadores................................................................................
• Capítulo 2 - Programação de Computadores
  • 2.1 Introdução
  • 2.2 Lógica de Programação
  • 2.3 Algoritmos
  • 2.4 Representação de Algoritmos
  • 2.5 Linguagens de Programação..............................................................................
  • 2.6 Variáveis
  • 2.7 Tipos de Dados
  • 2.8 Declaração de Variáveis
  • 2.9 Operadores
  • 2.10 Comandos de Entrada e Saída de Dados
  • 2.11 Exemplos de Algoritmos
  • 2.12 Exercícios em Classe
  • 2.13 Exercícios Complementares
• Capítulo 3 - Estruturas de Seleção
  • 3.1 Introdução
  • 3.2 Estrutura de Seleção Simples.............................................................................
  • 3.3 Estrutura de Seleção Composta
  • 3.4 Estrutura de Seleção Agrupada..........................................................................
  • 3.5 Exercícios em Classe
  • 3.6 Exercícios Complementares
• Capítulo 4 - Estruturas de Repetição
  • 4.1 Introdução
  • 4.2 Estrutura de Repetição Enquanto
  • 4.3 Estrutura de Repetição Faça-Enquanto..............................................................
  • 4.4 Estrutura de Repetição Para...............................................................................
  • 4.5 Exercícios em Classe
  • 4.6 Exercícios Complementares Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI
• Capítulo 5 - Introdução a Linguagem C
  • 5.1 Introdução
  • 5.2 Mapa de Memória em C
  • 5.3 Tipos de Dados em C.........................................................................................
  • 5.4 Inicialização de Variáveis..................................................................................
  • 5.5 Operadores em C................................................................................................
  • 5.6 Comandos de entrada e saída de dados..............................................................
  • 5.7 Estrutura de um programa em C
  • 5.8 Estrutura de Seleção...........................................................................................
    • 5.8.1 Comando de Seleção if .....................................................................................................
    • 5.8.2 Comando de Seleção switch .............................................................................................
  • 5.9 Estruturas de repetição.......................................................................................
    • 5.9.1 Comando while .................................................................................................................
    • 5.9.2 Comando do - while..........................................................................................................
    • 5.9.3 Comando for .....................................................................................................................
• Capítulo 6 - Arrays Unidimensionais (Vetores)
  • 6.1 Introdução
  • 6.2 Arrays unidimensionais
  • 6.3 Acessando elementos de um array unidimensional...........................................
  • 6.4 Inicialização de arrays
  • 6.5 Exemplos de manipulação de arrays..................................................................
  • 6.6 Exercícios em Classe
  • 6.7 Exercícios Complementares
• Capítulo 7 - Manipulação de Strings e Caracteres
  • 7.1 Introdução
  • 7.2 Funções para manipulação de strings
  • 7.3 Exercícios em Classe
  • 7.4 Exercícios Complementares
• Capítulo 8 - Arrays Bidimensionais (Matrizes)......................................................
  • 8.1 Introdução
  • 8.2 Declarando um array bidimensional..................................................................
  • 8.3 Exercícios em Classe
  • 8.4 Exercícios Complementares
• Capítulo 9 - Introdução aos Ponteiros..................................................................... Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI
  • 9.1 Definição............................................................................................................
  • 9.2 Declaração de ponteiros.....................................................................................
  • 9.3 Operadores de ponteiros (& e *)........................................................................
  • 9.4 Cuidados com ponteiros.....................................................................................
  • 9.5 Exercícios em Classe
• Capítulo 10 - Funções................................................................................................
  • 10.1 Introdução
  • 10.2 Protótipos de funções.......................................................................................
  • 10.3 Passagem de Parâmetros..................................................................................
  • 10.4 Passagem de arrays para funções.....................................................................
  • 10.5 Escopo de variáveis
  • 10.6 Exercícios em Classe
• Capítulo 11 - Estruturas
  • 11.1 Definição e declaração de estruturas em C......................................................
  • 11.2 Matrizes de estruturas
  • 11.3 Passando elementos de estruturas como parâmetros para funções..................
  • 11.4 Passando estruturas inteiras para funções........................................................
  • 11.5 Ponteiros para estruturas..................................................................................
  • 11.6 Comando typedef
  • 11.7 Exercícios em Classe
  • 11.8 Exercícios Complementares
• Capítulo 12 - Manipulação de arquivos em C
  • 12.1 Introdução
  • 12.2 Streams.............................................................................................................
  • 12.3 Abrindo um arquivo.........................................................................................
  • 12.4 Fechando um arquivo.......................................................................................
  • 12.5 Escrevendo e lendo caracteres em um arquivo................................................
  • 12.6 Escrevendo e lendo strings em um arquivo
  • 12.7 Funções fread() e fwrite()
  • 12.8 Exercícios.......................................................................................................
• Bibliografia...............................................................................................................

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

Um personagem muito importante para o desenvolvimento dos computadores atuais é Blaise Pascal. Esse matemático francês foi responsável pela criação de uma máquina de somar, a partir da qual foram criados diversos modelos. A máquina criada por Pascal foi chamada de Pascalina e na época foi considerada a perfeição em máquinas de calcular. Vale destacar que antes da Pascalina outros cientistas criaram outras máquinas mas que não tiveram desempenho tão bom quanto a Pascalina.

Outro matemático de grande importância foi Charles Babbage. Dentre as várias invenções de Babbage destaca-se a Máquina Analítica. A Máquina Analítica tinha alguns princípios básicos muito interessantes tais como:
Dispositivos de entrada;
Facilidade de armazenar números para processamento;
Processador, que na época era chamado de calculador numérico;
Unidade organizacional que tinha como função organizar as tarefas a serem executadas;
Dispositivo de saída com cartões perfurados;

É uma pena que a tecnologia disponível no tempo de Babbage não permitiu, pois teria sido um computador programável como conhecemos nos dias atuais.

Dentre esses dois grandes personagens citados há também uma figura feminina de destaque. Seu nome era Ada Augusta King, filha do poeta inglês Lord Byron. Ada foi amiga de Babbage. Sugeriu que a Máquina Analítica utilizasse o sistema binário e também escreveu pequenos programas para ela. Ada é considerada a primeira programadora de computadores do mundo.

Os desenvolvimentos não paravam e em toda parte do mundo cientistas desenvolviam suas engenhosas criações. Em 1930, a IBM lança uma máquina eletromecânica batizada de Harvard Mark I. O Mark I processava número com precisão de 23 dígitos e executava todas as quatro operações aritméticas, além de cálculos de logaritmos e funções trigonométricas. O Mark I também tinha programas embutidos. Era uma máquina lenta, mas era completamente automático.

Após o desenvolvimento do Mark I, o outro grande desenvolvimento americano foi o ENIAC (Electrical Numerical Integrator and Calculator). Era construído a base de válvulas e ocupava um espaço de 167 metros quadrados. Era um computador de alta velocidade e programável que usava a base de numeração decimal (base 10). Foi utilizado de 1946 a 1955.

1.3 Gerações dos Computadores

A evolução do computador segundo as tecnologias empregadas são divididas em gerações. Cada geração é caracterizada por um marco tecnológico. Basicamente os marcos tecnológicos utilizados para classificar a evolução dos computadores são três:
Válvulas eletrônicas;
Transistores;
Circuitos Integrados;

1ª Geração (1946 – 1958)
Caracterizada pelo uso de válvulas na composição dos computadores;
Entradas e saídas baseadas em fitas perfuradas;

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

Computadores aplicados a resolução de problemas técnicos, científicos e militares;
Programação baseada em linguagem de máquina;

2ª Geração (1958 – 1964)
Caracterizada pelo uso de transistores (talvez seja a invenção mais importante do século XX);
Entrada de dados através de cartão perfurado;
Surgimento dos primeiros Sistemas Operacionais;
Utilização de discos magnéticos removíveis;
Desenvolvimento e aplicação das primeiras linguagens de programação em substituição a linguagem de máquina;

3ª Geração (1965 – )
Utilização dos circuitos integrados em substituição aos transistores;
Surgimento do Sistema Operacional DOS (Disk Operating System);
Aumento significativo das capacidades de armazenamento;

4ª Geração (... ) Para alguns historiadores a 3ª geração vai até os dias atuais. Outros afirmam que a 3ª geração termina em 1970, dando inicio a 4ª geração, caracterizada pela utilização de circuitos integrados de larga escala e utilização de técnicas de Inteligência Artificial.

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

Dessa forma, a lógica de programação é a técnica de encadear pensamentos para atingir um determinado objetivo. Esse encadeamento representa uma seqüência lógica de passos a serem “seguidos” pelo computador. É através da lógica de programação que definimos a seqüência lógica de passos.

Uma seqüência lógica são passos executados até atingir um objetivo ou solução de um problema. Em programação de computadores, o termo “instruções” normalmente é utilizado no lugar de “passos”. Em ciência da computação, a instrução representa a “ordem” para que o computador execute uma determinada ação. A solução de um problema é obtida a partir de um conjunto de instruções e não apenas de uma instrução isolada.

2.3 Algoritmos

O termo algoritmos é o termo central na ciência da computação e em programação de computadores. Formalmente um algoritmo é uma seqüência lógica e finita de instruções escritas em uma linguagem de programação para se atingir a solução de um problema.

No dia-a-dia fazemos centenas de algoritmos. Por exemplo: tomar banho, tomar o café da manhã, trocar uma lâmpada, fazer uma ligação telefônica, uma receita de bolo, etc.

Um algoritmo apenas especifica os passos lógicos que devem ser seguidos pelo computador para se atingir a solução de um problema. O algoritmo não é a solução do problema porque se assim fosse, para cada problema existiria apenas um algoritmo.

Exemplo 1 : Algoritmo para calcular a média de três valores inteiros: Inicio Fornecer o primeiro valor inteiro; Fornecer o segundo valor inteiro; Fornecer o terceiro valor inteiro; Somar os três valores; Pegar o resultado da soma e dividir por 3; Mostrar o resultado obtido; Fim

Como pode ser observado no exemplo acima um algoritmo deve ser simples e mostrar de forma coerente como deve ser obtida a solução do problema. Algumas instruções não pode ser alteradas como, por exemplo, não podemos dividir o valor antes de somar e também não podemos somar os valores se os mesmos não forem fornecidos para o programa. Caso essa inversão ocorra é o que chamamos de erro de lógica. É como se fossemos beber um refrigerante em lata sem abrir a lata!

Como mostrado na figura 2.1, um programa é dividido em três partes básicas: entrada, processamento e saída. Se tivermos essa idéia em mente ao construir um algoritmo, a sua construção poderá ficar mais simples.

Para o exemplo 1 temos:
Quais são os dados de entrada? o Três números inteiros.
Quais são os dados de saída?

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

o A média dos três valores inteiros.

Qual é o processamento a ser realizado nos dados de entrada? o Somar os três valores inteiros e dividir o resultado por três.

Ao analisarmos o exemplo 1 novamente podemos identificar as três partes:

Inicio

Fornecer o primeiro valor inteiro; Fornecer o segundo valor inteiro; Fornecer o terceiro valor inteiro; Somar os três valores; Pegar o resultado da soma e dividir por 3; Mostrar o resultado obtido;

Fim

2.4 Representação de Algoritmos

Como vimos na seção anterior, um algoritmo nada mais é que um conjunto de instruções escritos em uma determinada linguagem. Essa linguagem é uma forma de representação do algoritmo. A representação pode ser através de:

Linguagem de programação: representa uma forma de escrever os algoritmos para que um computador possa entender e executar as instruções. Posteriormente estudaremos com mais detalhe os conceitos de linguagem de programação. Exemplo:

#include <stdio.h> void main() { int p1, p2, p3; float m; clrscr(); printf(“Informe o primeiro valor: “); scanf(“%d”, &p1); printf(“Informe o segundo valor: “); scanf(“%d”, &p2); printf(“Informe o terceiro valor: “); scanf(“%d”, &p3); m = (p1+p2+p3)/3; printf(“O resultado é %f”, m); getch(); }

entrada

processamento

saída

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

Mostrar “Reprovado”

Início

Informe o primeiro valor – p

Informe o segundo valor – p

Informe o terceiro valor – p 3

Calcular a media: M = (p1+p2+p3)/

M >= 6

Mostrar “Aprovado”

Fim

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

Pseudo-linguagem: é uma forma simples de representar algoritmos. A pseudo-linguagem usa a idéia de uma linguagem de programação, mas as instruções são escritas em linguagem natural (português, inglês, espanhol, etc). Outra vantagem é que na pseudo-linguagem não temos regras drásticas a serem memorizadas. Não existem convenções e a preocupação principal é apenas com lógica do programa.

Inicio inteiro p1, p2, p3; real m; imprima (“Informe o primeiro valor”) leia(p1) imprima(“Informe o segundo valor”) leia(p2) imprima(“Informe o terceiro valor”) leia(p3) m = (p1+p2+p3)/ imprima(“a média é “, m) Fim

Inicialmente adotaremos a pseudo-linguagem como forma de escrever os nossos algoritmos.

2.5 Linguagens de Programação

Com o surgimento dos computadores, os primeiros programas eram escritos em linguagem de máquina. A linguagem de máquina é uma linguagem complicada de se entender e de manipular, exigindo um grande conhecimento do funcionamento da máquina.

Inicialmente poucas pessoas conseguiam escrever um programa por causa dos motivos citados acima. Os programas eram extensos, de difícil manutenção e baixa produtividade.

Para facilitar a programação de computadores, surgiram as linguagens de programação. Uma linguagem de programação nada mais é do que um conjunto de regras e convenções que são utilizadas para escrever instruções em uma linguagem próxima da linguagem natural (normalmente o inglês) para que o computador possa executar. Para que a máquina consiga “entender” as instruções escritas em uma linguagem de programação, as mesmas devem ser “traduzidas” para a linguagem de máquina. Dessa forma, uma linguagem de programação pode ser vista como uma interface com a linguagem de máquina.

Desde o surgimento do computador diversas linguagens de programação foram desenvolvidas com vários propósitos: aplicações comerciais, científicas, etc. Exemplos de linguagens de programação: Fortan, Cobol, Pascal, Basic, Visual Basic, Delphi, Java, entre outras.

As linguagens de programação podem ser classificadas em dois grupos principais: linguagens de alto nível e linguagens de baixo nível. As linguagens de alto nível são linguagens desenvolvidas com o propósito comercial que não manipulam ou dificilmente manipulam a linguagem de máquina. Exemplos de linguagens de alto nível: Pascal, Fortran, Delphi, Java, etc.

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

Endereço Lógico Conteúdo Armazenado Frase “Hoje é feriado” Idade 25

Quando fornecemos um nome para uma posição de memória, o computador automaticamente associa o nome a um endereço físico de memória. Dessa forma, ao invés de manipularmos os endereços físicos trabalhamos apenas com os nomes das posições. A escolha de uma posição de memória é determinada automaticamente pelo computador quando o mesmo irá executar um programa.

O conteúdo de uma posição de memória não é um valor fixo, e durante a execução de um programa esse conteúdo pode variar. Portanto, o conteúdo de uma posição de memória é variável. As posições de memória que o computador manipula durante a execução de um programa damos o nome de variável.

Como já discutido, toda variável em um programa deve ter um nome e as regras para a formação do nome das variáveis mudam de uma linguagem de programação para outra. Antigamente, os nomes de variáveis eram restritos a apenas oito caracteres, mas com a evolução dos sistemas operacionais essa limitação já foi superada. Como o nosso curso será baseado em linguagem C, inicialmente adotaremos algumas regras próximas dessa linguagem. Eis as regras:

Utilize nomes sugestivos, relacionados com o conteúdo que a variável irá armazenar;
Nomes de variáveis deverão ser iniciados com caracteres e não com números;
Alguns símbolos especiais não são aceitos, tais como: *, !, ?, etc;
O underline (“_”) pode ser utilizado;

2.7 Tipos de Dados

Toda informação manipulada por um programa tem um tipo. O tipo é importante para que o computador possa armazenar de forma eficiente os dados a serem manipulados e também para saber quais são as operações básicas que podem ser realizadas com a variável.

A quantidade de tipos e os nomes podem variar de uma linguagem de programação para outra, mas os tipos básicos, chamados de tipos primitivos são:
Inteiro;
Real;
Caractere;
Cadeia de caracteres ou string;
Booleano ou lógico;

Tipo Inteiro:
Utilizado para armazenar valores numéricos sem casa decimal. Exemplo: 12, -12, 100, 0, -56, etc;
Operações que podem ser realizadas: adição, subtração, multiplicação, divisão, potenciação e resto de divisão (esta operação só é definida para valores inteiros);

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

Tipo Real:
Armazena valores numéricos com casa décima. Exemplo: 1.0, 2.456, -5.9090, 0.0, etc.
Operações que podem ser realizadas: adição, subtração, multiplicação, divisão, potenciação;

Tipo Caractere:
Utilizado para armazenar um único caractere (podendo ser um dígito ou não). Exemplo: ‘1’, ‘a’, ‘A’, ‘*’, ‘?’, ‘/’, ‘:’, etc.
Os valores caracteres são representados entre apóstrofo (‘’) para diferenciar dos nomes das variáveis;

Tipo String (cadeia de caracteres):
Uma string é formada por dois ou mais caracteres. Exemplo: “aa”, “Maria”, “Pedro”, “112”, etc;
Toda string é representada entre aspas (“”). Isso é necessário para diferenciar do nome das variáveis;

Tipo Booleano:
Representado por apenas dois valores excludente: verdadeiro ou true e falso ou false;

2.8 Declaração de Variáveis

Como já sabemos, uma variável é uma posição de memória que será utilizada por um programa para armazenar informações que serão manipuladas. Toda variável a ser utilizada em um programa dever ser declarada.

Declarar uma variável significa fornecer um nome para a mesma e também indicar o tipo de dado que a variável irá armazenar. Do ponto de vista da máquina, quando declaramos uma variável o computador simplesmente “reserva” um endereço físico para armazenar informações e também associa a esse endereço físico um nome (endereço lógico). Através do tipo, o computador determina a quantidade de memória para cada variável e também “sabe” quais são as operações possíveis para cada uma.

Existem algumas linguagens de programação que não exigem a declaração de variáveis. Programas escritos nessas linguagens são mais complicados de serem entendidos e também de dar manutenção. A maneira de declarar variáveis varia. A sintaxe em Porto-C para declarar uma variável é:

< tipo_de_dado > < nome_da_variável >

onde tipo_de_dado é qualquer tipo válido na linguagem e nome_da_variável será o endereço lógico a ser manipulado. Exemplo de declaração de variável:

inteiro a real b caractere c inteiro x, y, z

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

Operadores Aritméticos Os operadores aritméticos básicos presentes nas linguagens de programação são:

Operação Símbolo Exemplo Adição + A + B Subtração - A – B Multiplicação * A * B Divisão / A / B

Em Porto-C iremos adotar dois operadores adicionais:

Operação Símbolo Exemplo Potenciação ^ A ^ B Resto da divisão inteira % A % B Raiz quadrada sqrt() sqrt(A)

Um detalhe que deve ser enfatizado é o fato de que a ordem dos operadores aritméticos é o mesmo expresso pela matemática.

1. Potenciação e radiciação
2. Multiplicação ou divisão ou resto de divisão (a operação que vier primeiro na expressão)
3. Adição ou subtração (a operação que vier primeiro)

Para dar prioridade a uma operação, utilizamos apenas parênteses. Na matemática além dos parênteses, utilizamos chaves e colchetes, mas em computação só parênteses. Exemplo:
A + B * C
(A + B) * C
A – B * C + D * E
A – B * C + D * E / F

Exemplo : Algoritmo para exemplificar o operador de atribuição e os operadores aritméticos.

Início inteiro x, y, z x = 10 y = 2 z = x / y x = x % y Fim

Operadores Relacionais Enquanto os operadores aritméticos são utilizados para realizar cálculos matemáticos com o conteúdo das variáveis, os operadores relacionais como o próprio nome indica são utilizados para relacionar o conteúdo das variáveis. Ao relacionar o conteúdo das variáveis conseguimos descobrir

Algoritmos / Linguagem C – Prof. Ms. Antonio Marcos SELMINI

se os conteúdos são iguais ou diferentes, se o conteúdo de uma variável é maior ou menor que o conteúdo de outra variável.

Os operadores relacionais são:

Operação Símbolo Exemplo Igualdade == A == B Maior > A > B Maior ou igual >= A >= B Menor < A < B Menor ou igual <= A <= B Diferente != A != B

Quando utilizamos os operadores aritméticos o resultado será um valor numérico, mas quando utilizamos os operadores relacionais o resultado será um valor booleano (verdadeiro ou falso). Por exemplo: considere duas variáveis inteiras com os seguintes conteúdos A ← 3 e B ← 10.

Operação Resultado A == B Falso A != B Verdadeiro A >= B Falso A <= B Verdadeiro

Operadores Lógicos Os operadores lógicos são extremamente importantes no desenvolvimento de programas porque normalmente podemos ter várias expressões aritméticas e relacionais e devemos combinar os seus resultados afim de obter apenas um. Os operadores lógicos são utilizados para esse propósito.

O resultado de uma expressão com a utilização dos operadores lógicos é booleano. Em algoritmos iremos utilizar três operadores lógicos: E, OU e NÃO. A operação E resulta em um valor verdadeiro se todos os operandos tiverem valor verdadeiro, caso contrário o resultado será falso. Para a operação OU o resultado será verdadeiro se um dos operandos tiverem resultado verdadeiro e será falso somente quando todos os operandos tiverem valor falso. A operação NÃO é utilizada para inverter o resultado de uma operação. Veja a tabela abaixo:

Tabela Verdade:

p q p E q NÃO(p E q) p OU q NÃO(p OU q) Verdadeiro Verdadeiro Verdadeiro Falso Verdadeiro Falso Verdadeiro Falso Falso Verdadeiro Verdadeiro Falso Falso Verdadeiro Falso Verdadeiro Verdadeiro Falso Falso Falso Falso Verdadeiro Falso Verdadeiro