Introdução à Orientação a Objetos

Olá pessoal! Depois da nossa série de posts para programadores iniciantes, vamos começar aqui uma nova série, avançando um pouco mais no mundo da programação. Nesta série, falaremos sobre os principais conceitos da Orientação a Objetos, o paradigma mais utilizado hoje no mercado. Esta série (bem mais curta que a outra), servirá de base para que possamos seguir em frente em nossos estudos, para desenvolvermos aplicações Web (que está planejado para ser uma terceira série de posts). Na orientação a objetos, normalmente não se usa a representação algorítmica, como na programação estruturada, mas sim a representação na forma de diagramas, utilizando a Unified Modeling Language (UML). Para as partes práticas, pretendo demonstrar os conceitos utilizando as linguagens C++ e Java. Para o desenvolvimento dos aplicativos em C++ recomendo o Code::Blocks (o mesmo que utilizávamos para escrever códigos em C) ou o Visual Studio Express e para Java recomendo o Eclipse ou o NetBeans. Lembrando que, para o desenvolvimento de aplicações em Java, é necessário instalar o Java Development Kit (JDK), que pode ser baixado no site da Oracle. Todas as ferramentas citadas aqui são gratuitas e, com exceção do Visual Studio, estão disponíveis tanto para Windows, quanto para Linux e Mac. Em um momento oportuno, posso escrever um post a respeito da utilização de algumas dessas IDEs.

Bom, então vamos começar a falar sobre a Orientação a Objetos. 🙂

A orientação a objetos (OO) é um paradigma (uma espécie de fórmula, ou melhor, metodologia) de análise, projeto e programação de sistemas de software. O termo foi criado por Alan Kay, criador da linguagem Smalltalk. Hoje em dia, grande parte das linguagens utilizam esse paradigma, como Java, C#, C++, Object Pascal (Delphi), Ruby, Python, PHP (a partir da versão 4) etc. Mas não vamos nos prender muito a história e vamos entender o que vem a ser a OO.

Antigamente, o objetivo principal dos desenvolvedores era otimizar o código, principalmente pelo motivo de que o hardware na época era um tanto quanto limitado com relação aos recursos. Esse tipo de desenvolvimento, muitas vezes melhorava o aplicativo, em detrimento ao desenvolvimento, que era mais trabalhoso. Nessa época, o paradigma estruturado era o que dominava o mercado (o tipo de desenvolvimento que vimos na primeira série de posts.) Com o tempo, viu-se a necessidade de uma nova forma de desenvolver software. Queria-se um nível de abstração maior, de forma que o planejamento e o desenvolvimento do software se assemelhasse com o mundo real. No mundo real, interagimos com as coisas. E cada uma dessas “coisas” que interagimos, tem características e fazem certas ações. Assim, essas “coisas” foram chamadas de objetos. Passou-se então a pensar em objetos interagindo no software. Surgia assim a Orientação a Objetos.

Ao projetar sistemas utilizando a OO, identificamos as entidades, que são essas “coisas” que comporão o nosso software. Essas entidades, ao passarmos para a programação, essas entidades se tornarão as classes. As classes tem, basicamente, duas partes principais. A primeira dela, é a parte de características. É nessa parte que temos as informações a respeito da classe. Por exemplo, uma classe chamada Pessoa. O que temos com relação às características? O nome, a data de nascimento, o tipo sanguíneo, etc. Na programação, essas características são conhecidas como variáveis de instância. A segunda parte é a parte que define o comportamento da classe. Ainda seguindo o exemplo de uma classe chamada Pessoa, teríamos ações como andar, falar, bater o coração (por que não?), respirar, etc. Na programação, as coisas que determinada classe faz são chamadas de métodos. Então, podemos dizer que as classes são compostas de variáveis de instância e métodos.

Tá bom… eu to falando aqui de classes e tal… mas e os objetos? Afinal é orientação a objetos, não é? Sim sim, claro. O que acontece é que não trabalhamos diretamente com as classes, e sim com os objetos. As classes são usadas para construir os objetos. Uma classe é o projeto de um objeto. Ela diz como o objeto deve ser criado. É como se fosse o tipo do objeto (tipo no conceito de tipos na programação). Vamos pensar em um exemplo. No meu programa tenho uma classe Botão. A classe Botão será usada para criar vários botões (cada um, um objeto), cada qual com suas próprias características. Como assim? Mas as características não são definidas na classe? Mais ou menos. Continuando com o exemplo do Botão. Podemos definir na classe que um botão terá características como cor, tamanho, forma, rótulo. Cada um dos objetos do tipo botão, terá suas próprias características: sua própria cor, seu próprio tamanho, etc.

Antes de eu mostrar como funciona isso na prática, apenas vou fazer algumas breves explanações a respeito das linguagens que iremos utilizar para ilustrar a OO. Em C++, que foi derivado do C, temos também a função main() (derivada do paradigma estruturado) que define o ponto onde o programa é inicializado. Já no Java, não temos funções. Tudo nele é orientado a objetos, de forma que não temos funções. Um programa é executado através de um método de uma classe, que também deve ser chamado de main. Ao executarmos um programa, indicamos a classe que possui tal método e então, a partir dele, é iniciada a execução.

Vamos pegar como exemplo a classe Cachorro. Vamos criar essa classe e definir objetos a partir dela. Percebam que a sintaxe das duas linguagens são bastante parecidas com a linguagem C. O conjunto de linguagens com esse estilo de sintaxe é conhecida como linguagens C-Like. Mas logo em seguida, vou explicar alguns elementos principais da linguagem.

Primeiro em C++…

… e depois em Java…

Em uma visão geral, no exemplo acima, criamos uma classe chamada Cachorro, com as variáveis de instância tamanho, raça e nome, além do método latir(). A partir dessa classe, criamos um objeto chamado cachorro, atribuímos valores às suas variáveis de instância e, em seguida, fizemos uma chamada ao método latir, que escreve “Ruff! Ruff!” na tela, pulando para a próxima linha logo em seguida. Vamos agora analisar como isso foi feito nas duas linguagens.

Primeiramente, vamos analisar o código-fonte na linguagem C++. Em ambas as linguagens, é convenção declararmos cada classe em um arquivo separado. No caso do C++, cada classe é composta de um arquivo .h (declaração) e um arquivo .cpp (implementação). No arquivo de cabeçalho, cachorro.h, Iniciamos com um comentário (da mesma forma como fazíamos em C), e em seguida incluímos alguns arquivos. O arquivo iostream é parecido com o stdio que utilizávamos em C. É ele que nos fornece os meios de realizarmos, por exemplo, uma escrita na tela ou uma leitura de teclado. Isso é feito através dos objetos cout e cin. Esses objetos são objetos de fluxo, ou seja, direcionamos conteúdo a eles, e eles o mostram na tela (no caso do cout). Veremos mais sobre objetos de fluxo no decorrer dos posts. Logo em seguida, incluímos o arquivo string, que possui a declaração de uma classe de mesmo nome. Em C, utilizávamos vetores do tipo char para representar strings. Já em C++, temos essa classe que nos fornece mais recursos com relação a esse tipo de dados. Essa classe resolve as questões relativas a alocação de memória, além de nos fornecer métodos para obtermos o tamanho da string, concatenar uma string com outra, obter porções da string, etc. Por isso, ao programar em C++, é sempre bom utilizar a classe string ao invés do tipo char*. Ah, e se precisar, por algum motivo, do vetor de caracteres, a classe string pode lhe fornecer o vetor correspondente através de um método chamado c_str(). Mas não vamos nos preocupar com isso agora. Logo após os includes, temos using namespace std. O uso de namespaces no C++ serve, dentre outras coisas, para que possamos ter classes de mesmo nome no programa. Como assim? É uma coisa que acontece mais em projetos maiores, mas por exemplo, eu posso ter duas classes cachorros. Uma no namespace canil e outra no namespace petShop… pode parecer meio inútil agora, mas em alguns casos mais específicos pode ser a solução. Nessa linha do código, dizemos que estamos utilizando o namespace de nome std em todo o código desse arquivo. Isso nos poupa de ficar digitando o namespace, por exemplo, em std::cout, std::string, etc. Em seguida começamos a declaração propriamente dita da nossa classe. A palavra-chave class seguida do nome da classe. Por convenção, colocamos a primeira letra em maiúsculo no nome da classe. Iniciamos então o escopo da classe com as chaves. Perceba que ao final da classe, deve-se colocar ; da mesma forma que fazíamos nas structs em C. Temos logo no início da classe o label public. Isso significa que tudo que vier após esse label poderá ser acessado de fora da classe. Não se preocupe muito com isso agora. Veremos mais a fundo isso no próximo post sobre encapsulamento. Temos, inicialmente a declaração das variáveis de instância da nossa classe: o atributo tamanho do tipo inteiro, e os atributos raca e nome, que são objetos da classe string. Em seguida, temos a declaração do método Construtor e Destrutor da classe. Esses métodos, que são obrigatórios em C++, representam o que a classe fará ao ser inicializada e ao ser encerrada. Por exemplo, ao criar um objeto do tipo Cachorro, automaticamente será chamado o método construtor, Cachorro(). O método destrutor será chamado quando a execução sair do contexto onde a classe foi criada (por exemplo, no bloco entre chaves onde a classe foi declarada) ou quando ela for explicitamente desalocada (veremos isso mais adiante, quando virmos alocação dinâmica). Em seguida temos o método latir() que não recebe nada e não retorna nada. Perceba que métodos nada mais são que funções dentro da própria classe. Os métodos são funções correspondentes ao “tema” da classe. Por exemplo, o método latir() faz sentido dentro de uma classe Cachorro, mas não faria sentido numa classe chamada Vaca. Perceba que no arquivo de cabeçalho apenas declaramos os métodos – como se fossem os “protótipos” dos métodos -, a implementação vai no arquivo .cpp. O nosso arquivo cachorro.cpp começa com a inclusão dos arquivos de cabeçalho: o arquivo iostream, pois usaremos o objeto cout no método latir() e o arquivo cachorro.h que contém a declaração de nossa classe. Iniciamos então com o construtor e o destrutor. A sintaxe em C++ na hora de implementar os métodos é <retorno> NomeDaClasse::NomeDoMétodo(<Argumentos>) {}. Percebam que o construtor e o destrutor são diferentes, pois por padrão não possuem nem argumentos, nem valor de retorno – isso pode não acontecer (veremos isso mais a frente, quando falarmos sobre sobrecarga de operadores). Logo em seguida, temos a declaração do nosso método latir(). Simplesmente jogamos para o objeto cout (que escreve dados na tela) a string “Ruff! Ruff!” através do operador <<. Enviamos também uma quebra de linha, em C++ representada pelo endl. Poderíamos também, como em C, o caractere n para pularmos de linha. Por fim, no arquivo main.cpp temos a nossa já conhecida função main(). Nela, incluímos o arquivo cachorro.h que contém a declaração de nossa classe e o iostream. Criamos então um objeto chamado cachorro (reparem que a declaração de um objeto se assemelha muito a declaração de uma variável. Só que ao invés de um tipo primitivo, temos uma classe. O objeto é uma variável do tipo daquela classe). O acesso aos itens da classe se dá pelo operador . da mesma forma que fazíamos o acesso às structs em C (exceto quando a alocação for dinâmica. Aí, utilizamos o ->). Simplificadamente (bastante simplificadamente), uma classe é uma “struct com funções”. Para essa primeira parte, essa definição é suficiente. Assim, terminamos a explicação do código em C++. Quaisquer dúvidas, postem aqui nos comentários.

Bom, agora vamos explicar o código-fonte em Java. Em Java, como eu disse acima, a execução é inicializada a partir de um método main de uma classe (Java não tem funções ou procedimentos como C++). Dessa forma, declaramos o nosso método main dentro da própria classe Cachorro. Outra coisa é que em Java, toda a declaração da classe é feita em um único arquivo .java. Dessa forma, em nosso exemplo, temos apenas o arquivo Cachorro.java. Lembrando que o nome do arquivo deve coincidir com o nome da classe que ele contém. Bom, iniciamos o código com a declaração do pacote. Pacotes são uma alternativa para estruturar e organizar as classes em uma aplicação Java. Verificando-se externamente ao código, nada mais é que uma estrutura de pastas. Nesse nosso exemplo, na raiz do projeto teríamos uma pasta chamada canil, dentro dela outra pasta chamada exemplo e por fim o nosso arquivo Cachorro.java. Por convenção, os nomes de pacotes devem sempre ser em minúsculo. Por enquanto pode parecer besteira, mas é uma forma útil de organizar suas classes quando seus projetos começarem a crescer. Em seguida, temos a declaração da classe. Encontramos aqui algumas diferenças para o C++. A primeira delas é que a declaração da classe possui um classificador de acesso, no caso, o public. Em Java, se a classe não for definida como pública, ela somente poderá ser acessada dentro do próprio arquivo em que foi declarada. Geralmente, quando temos somente uma classe declarada no arquivo, ela é declarada como pública. Outra diferença para o C++ é que a definição do escopo da classe não termina com o ponto-e-vírgula! Fiquem atentos a isso para evitar erros de sintaxe. Em seguida, temos a declaração dos atributos da classe. No caso do Java, também deve-se ficar atento, pois os identificadores de acesso vem antes de cada um dos atributos ou métodos. Outro detalhe é que a declaração de strings é feita com letra maiúscula! Em Java, todas as classes tem seu nome em maiúsculo – e como String é uma classe, ela tem seu nome em maiúsculo! No método latir, o único comentário a ser ponderado é o método para a escrita de texto na tela. Como eu disse anteriormente, em Java tudo são classes. Assim, a biblioteca padrão define uma classe chamada System para representar o sistema. Porém, ela é definida como estática, ou seja, não é possível instanciá-la (criar objetos a partir dela). Dessa forma, acessamos seus métodos e atributos diretamente – no caso o atributo out que representa a saída de vídeo, e chamamos seu método println, que escreve uma linha na tela e pula para a próxima linha em seguida. Depois, temos a declaração do método main, que é o ponto inicial de nosso aplicativo. Sua declaração sempre deve ser assim, declarado como public static void (ou seja, método público, estático (não é necessário instanciar a classe para executá-lo) e não retorna nada), recebendo um vetor de objetos String como argumento (sim, a declaração de vetores no Java é um pouco diferente que o C++… veremos isso com mais detalhes quando for oportuno). Bom, no método main, declaramos um objeto do tipo Cachorro e o instanciamos com o uso do new. Em Java, tudo é referência (apesar de não existirem ponteiros). Assim, precisamos instanciar explicitamente nosso objeto, caso contrário ele permanecerá vazio (null). No mais, atribuímos valores às variáveis de instância da classe e chamamos o método latir(). E encerramos a explicação do código em Java.

Bom pessoal, nesta primeira parte, vimos o conceito de orientação a objetos, qual a diferença entre uma classe e um objeto, além de fazermos um exemplo bem básico, pra já irmos nos acostumando com as linguagens. Aguardem o próximo post, onde falaremos sobre um assunto muito importante na OO: Encapsulamento de Dados!

Até lá!

Introdução à Linguagem C – Parte III

Olha eu aqui de novo. Como havia prometido, nessas férias vou movimentar um pouco as coisas por aqui, já que ao longo do ano a coisa vai ser feia. Último ano da faculdade, projeto de conclusão de curso, a minha tentativa de conseguir um mestrado vai ser colocada em prática, enfim, uma correria que só vendo.

Mas vamos parar com a conversa fiada e começar com a ação. Como prometido, nesta terceira e última parte da Introdução à Linguagem C, veremos os dois assuntos pendentes em relação a linguagem Pascal, tomando por base o ponto no qual nos encontramos: registros e as funções e procedimentos.

Bom, não vou me aprofundar muito no conceito do que seria um registro (há um post inteiro dedicado a eles), apenas vou citar as “novidades” na linguagem C. Bom, primeiramente, em C os registros são conhecidos como estruturas ou melhor, pela palavra chave struct. As structs são simplesmente agrupamentos variáveis. Vamos visualizar as diferenças de sintaxe, e em seguida explicaremos suas particularidades (utilizando o mesmo exemplo do post sobre registros):

Bom, no exemplo acima vocês tem a comparação entre o Algoritmo, a sintaxe em Pascal e a sintaxe em C. Neste caso citado acima, estamos utilizando registro para criar um novo tipo, chamado de Aluno (só relembrando, a linguagem C é case sensitive, ou seja, ao contrário da linguagem Pascal, Aluno e aluno são coisas diferentes!), criando em seguida uma variável desse novo tipo, com o nome umAluno. Posteriormente explicarei com mais detalhes o uso do typedef.

Utilizar um registro para definirmos um tipo é vantajoso apenas se utilizaremos esse tipo em vários locais do programa. Se fossemos utilizar apenas em um ponto do aplicativo, por exemplo, poderíamos fazer assim:

Isso também resultaria em uma variável de nome umAluno, com os campos nome e idade. “Certo… mas e se eu precisasse passar um registro desse por parâmetro para uma função? Como eu declararia isso?”. Bom, caso você precise passar um registro por parâmetro em uma função, precisaremos nomear essa nossa estrutura. De que forma? Adicionando um identificador entre a palavra reservada struct e o abre chaves. Por exemplo:

Lembrando apenas que, para que seja possível passar essa estrutura como parâmetro em funções, sua declaração deve ser feita de forma global (fora de qualquer função ou procedimento) e antes do seu primeiro uso. Ao final do post, quando exemplificarmos a declaração de funções, teremos um exemplo disso. 😉

Com relação a sintaxe dos registros em C, não há muito mistério. Iniciamos com a palavra reservada struct, seguida ou não do identificador daquela estrutura. Em seguida, temos a definição dos campos que comporão aquela estrutura. Isso é feito da mesma forma que declaramos variáveis (observe os exemplos citados acima). Após o fecha chaves, podemos ter um nome de variável, que terá como forma essa estrutura. No final, encerra-se a declaração com ponto e vírgula. Cabe frisar que, caso não haja um nome de variável após a definição dos campos, você terá declarado apenas a estrutura, e não uma variável com o formato da estrutura. Ficou um pouco confuso? Vou tentar explicar melhor. Ao declarar uma estrutura, o struct { … } apenas indica o formato dela, mesmo que você coloque o identificador entre o struct e o {. Digamos assim. Se escrevermos int a; teremos uma variável do tipo inteiro. Se escrevermos struct { … } a; teremos uma variável do tipo da estrutura que definimos. Um dos motivos de frequentemente utilizarmos o typedef é para evitarmos de ter que sempre colocar struct <algumacoisa> sempre que precisarmos utilizar essa estrutura em nosso programa. Para finalizar as dúvidas: o identificador entre o struct e o { é o nome da estrutura e o que vem depois do } e antes do ; é então a declaração de uma variável do tipo da estrutura. Quaisquer dúvidas sobre o assunto, deixem nos comentários que eu tento explicar melhor.

Para acessar os campos da estrutura, assim como na linguagem Pascal, utilizamos o . seguido do nome do campo. Por exemplo:

Como pode ser visto, não tem nenhum mistério ao acessar os campos do registro. Esse tipo de acesso só não vai se alterar quando a struct for um ponteiro, mas isso discutiremos no post sobre ponteiros, mais adiante. Só atentem que o segundo argumento da chamada à função scanf, quando o valor é um vetor de caracteres (string), não usa-se o operador & (na 1ª parte desta introdução falei sobre isso).

Concluída então a nossa discussão a respeito de registros, falaremos então a respeito de funções e procedimentos. A primeira coisa que tenho a falar é que, em C, não há distinção entre função e procedimento. Como assim??? É. Ao contrário da linguagem Pascal que define uma palavra chave para função (function) e uma para procedimento (procedure), na linguagem C não há essa distinção. A único detalhe que definirá um procedimento de uma função, e o tipo void como retorno da função, pois em C os procedimentos também podem conter a palavra return ao final de seu escopo. Estranho, né? Vamos então a alguns exemplos de função, em Algoritmo, Pascal e C:

A declaração de uma função inicia com o tipo de retorno, no caso deste exemplo, um valor inteiro (int). Logo em seguida, temos o nome de nossa função, seguida com a lista de argumentos, devidamente acompanhados de seus tipos, separados por vírgula (e não ponto e vírgula, como em Pascal) e circundados por parênteses. Logo em seguida, definimos o escopo de nossa função em um bloco entre chaves. O processamento ocorre da mesma maneira com que nas outras partes do programa. O bloco é encerrado pelo retorno, ou seja, a palavra chave return seguido do valor constante ou variável, entre parênteses ou não.

Como já adiantei anteriormente no post, a declaração de um procedimento apenas se diferencia pelo fato do tipo de retorno ser void (o tipo vazio, lembram-se?). Além disso, pode-se simplesmente omitir a linha de retorno ou colocar apenas return; como verificaremos no exemplo a seguir.

Viu? Praticamente nenhuma diferença em relação às nossa funções.

Bom, então aqui finalmente encerramos a nossa Introdução à Linguagem C, depois de três longos posts. Quaisquer dúvidas que por acaso permanecerem, por favor postem nos comentários, pois a sua dúvida pode ser também a dúvida de outras pessoas. Mais uma vez peço encarecidamente que não me enviem programas para eu fazer. Esses exercícios que o curso técnico / faculdade pedem são de suma importância para fixar o conteúdo e desenvolver o seu raciocínio lógico. Devido ao grande número de e-mails que recebo desse tipo, tenho simplesmente que ignorá-los…

Espero ter ajudado com essa série de posts, e vamos que vamos. Em breve (ou não, vai depender do tempo), continuaremos com essa série de posts didádicos, falando sobre os temidos ponteiros!!! Até lá! 🙂

Procurando a parte 1 ou parte 2 dessa introdução?

Introdução à Linguagem C – Parte II

Olá pessoas! Aqui estou eu novamente pra mais um post da nossa série de aprendizado. Como prometido, neste post vamos completar alguns conceitos básicos da programação estruturada que já havíamos estudado na linguagem Pascal, mas dessa vez na linguagem C. No post passado, falamos da estrutura de seleção se (ou if). Outra estrutura de seleção também muito utilizada é o switch (em Pascal, utilizávamos o case). Com o switch, comparamos o conteúdo de uma variável com algumas constantes, e dessa forma selecionamos que trecho de código nossa aplicação irá executar. Abaixo, um trecho de código mostrando essa estrutura em Algoritmo, Pascal e em C. Logo após falaremos sobre os detalhes da sintaxe:

Temos algumas características interessantes a serem discutidas nesse trecho de código. Na estrutura switch, temos a palavra chave switch seguida do nome da variável que será comparada com as constantes. Neste exemplo, supomos que temos uma variável inteira (int) de nome ‘voto’. Em seguida, temos as comparações definidas. Elas são compostas da palavra chave case (que define um caso de teste), seguida da constante com a qual queremos comparar. Esta constante não precisa necessariamente ser um valor inteiro. Pode ser um caractere, um ponto flutuante, etc.

Após a constante, colocamos : indicando que ali se inicia o trecho de código correspondente àquela decisão. Após os dois pontos, podemos ou não abrir chaves. É raro ver quem faz isso, mas fica do gosto de cada um. Alguns preferem por questão de organização, mas nada que um identamento bem feito não resolva. Enfim, usem ou não as chaves para definir este trecho de código (nos exemplos aqui do blog, não utilizarei). No caso deste exemplo nosso, incrementamos as variáveis correspondentes, simulando que cada uma representaria um candidato específico em uma eleição (logo à frente explicarei esta maneira ‘diferente’ de incrementar variáveis em C).

Ao fim do código de cada bloco case, temos a palavra chave break. O programa, ao encontrar o comando break, sai da estrutura case, “pulando” para a próxima linha depois do fecha chaves. “Nossa, mas por que essa complicação??”. A estrutura switch funciona com “labels”. Quando você define uma comparação case, você está na verdade definindo uma “marcação” à estrutura. Ao executar, o programa vai procurar dentro desses “labels” definidos até encontrar uma comparação que satisfaça o conteúdo atual da variável. Os labels são apenas “marcadores”, ou seja, precisamos do break para avisar que ali se encerra o “bloco”. Caso não coloquemos a palavra chave break, o aplicativo continuará sua execução linearmente, passando pelos blocos de código dos outros casos de teste. Em geral, na linguagem C, a palavra break indica que o programa deve sair da execução de uma estrutura (de seleção ou de repetição). Por exemplo, se estivermos dentro de um while e o programa encontrar a palavra break, ele irá pular para a primeira linha após o fecha chaves (ou o encerramento) da estrutura while. Paralelamente ao break, temos a palavra chave continue que faz o contrário: faz o programa voltar à primeira linha da estrutura em que ele se encontra (no exemplo do while, voltaria para a primeira linha do bloco de código definido por ele). Em situações mais propícias, faremos uso dele e exemplificaremos melhor.

Continuando, caso a variável do switch não satisfaça a nenhum dos casos de teste definidos, ele procurará pela palavra chave default que indica o que fazer quando todos os casos de teste falharem. Caso não haja nenhuma ação a ser realizada caso a variável não corresponda a nenhum dos casos de teste, podemos omitir o trecho default ou deixá-lo vazio. Perceba que ele não possui a palavra chave break, pois já é o último “caso” definido, e seguindo sua execução, sairá automaticamente da estrutura switch.

Nesse trecho demonstrado acima, temos uma forma bastante interessante de incrementar variáveis. Ao colocarmos o nome de uma variável seguido de ++, simplesmente pegamos o valor que ela possui e acrescentamos 1. Simples e rápido. Podemos fazer a mesma coisa para decrementarmos, utilizando (bastante lógico, não?). Vocês podem já ter visto estes incrementos e decrementos antes e depois do nome da variável. Assim:

Qual seria, então a diferença entre as duas formas? Na verdade, só fará diferença caso você esteja utilizando o operador de incremento dentro de uma expressão. Se o incremento estiver antes do nome da variável, o incremento será realizado antes do valor da variável ser utilizado na expressão. Se estiver depois, será utilizado depois. Veja o exemplo abaixo:

Simples, porém necessita de atenção ao utilizar uma forma ou outra. Fica a dica!

Bom, já somos capazes de fazer decisões com o nosso programa, utilizando as estruturas if e switch da linguagem C. Para encerrarmos esta segunda parte da introdução à linguagem C, iremos ver como fica a sintaxe das estruturas de repetição. A primeira que iremos ver é a estrutura while. Como pode ser visto nos exemplos a seguir, sua estrutura é bastante semelhante à sua correspondente em Pascal. No exemplo, temos versões em Algoritmo, Pascal e C:

Como pode ser percebido, a estrutura while na linguagem C é bem mais “resumida” em comparação com a linguagem Pascal. Nela, inserimos a palavra chave while, seguida da condição para a realização da repetição entre parênteses (neste exemplo, a variável ‘contador’ ser menor que 18). Logo após, temos o abre chaves que define o bloco de repetição. Caso o bloco de repetição tiver apenas um comando, pode-se omitir as chaves. Neste nosso exemplo, temos um estrutura condicional que será repetida. Nenhuma novidade, a não ser o ‘operador’ += que eu inseri ali. Este operador nada faz do que somar ao valor atual da variável o que temos após ele. No exemplo, estamos somando 2 ao valor da variável ‘contador’. Bastante objetivo, não? O mesmo pode ser feito com os outro operadores (-=, *=, /= …). Mais uma dica para agilizar a escrita de seus códigos em linguagem C! 🙂

Outra estrutura de repetição utilizada é o do-while. Ele difere-se um pouco do nosso repeat-until do Pascal, pois no do-while ele repete o bloco enquanto a condição é satisfeita, enquanto que no repeat-until repetia-se enquanto a condição não era satisfeita. “Mas como eu vou portar meus códigos de Pascal pra C, se não existem estruturas iguais?”. Basta adaptar a condição. Nos exemplos a seguir, veremos códigos equivalentes em Algoritmo, Pascal e C:

Bom, a sintaxe é bastante simples, e semelhante ao while já demonstrado anteriormente. Iniciamos com a palavra chave do e o bloco de código definido entre chaves. Após o bloco, temos a palavra chave while e a condição para a execução do bloco entre parênteses. O único detalhe é que, após a condição, é necessário o uso de ponto e vírgula. Quando a adaptação do código em Pascal, se vocês perceberem, basta “inverter” a condição. Em Pascal, a condição era “menor que 200”. Em C, ficou “maior ou igual a 200”, ou seja, a faixa de valores contrárias à versão em Pascal.

Veremos agora, para encerrar essa segunda parte da Introdução à Linguagem C. O laço de repetição for tem uma estrutura relativamente diferente do que era visto na linguagem Pascal. Vejamos um exemplo prático em Algoritmo, Pascal e C, e em seguida discutiremos as particularidades da sintaxe e estrutura desse laço em C:

Podemos logo de cara dizer que sua estrutura é diferente da linguagem Pascal. Vamos explicar trecho a trecho como ela funciona. Primeiramente, é bom lembrar que em Pascal, a estrutura for incrementava automaticamente a variável definida em seu escopo automaticamente (nesse exemplo acima, a variável ‘indice’). Em C, isso não é regra. Já já veremos por que.

Primeiramente, temos a palavra chave for, seguida das regras de suas regras de execução entre parênteses. Se vocês perceberem, temos três subdivisões dentro dos parênteses. A primeira parte (no exemplo acima, indice = 0) indica o que deve ser feito antes de começarmos a inicialização do for. Neste caso, atribuiremos o valor 0 para a variável chamada indice. Podemos realizar mais de uma instrução de inicialização, separadas por vírgula. “Como assim?”. Vamos supor que queremos inicializar duas variáveis, i e j. colocaríamos for (i = 0, j =3; i < 40; i++, j–). Alguma coisa assim.

O segundo “parâmetro” do for é a condição que deve ser satisfeita para que o for continue sendo executada. Antes de executar o bloco de código, ele verifica essa condição. Foi satisfeita? Não? Então executo de novo. Foi satisfeita? Sim? Então eu pulo para a próxima instrução depois do bloco do for. Devemos sempre tomar um certo cuidado com essas condições, não só no for, mas também no while e no do-while, para evitarmos que o nosso programa fique em um looping infinito e nunca termine sua execução. Por isso, atenção ao programar!

A última parte indica o que deverá ser feito após cada execução do for. No exemplo que definimos ali em cima, iremos incrementar em 1 a variável chamada indice (olhem lá o nosso operador “especial”). Como mostrei acima, pode ser definida mais de uma ação neste “parâmetro”, como um incremento e um decremento. Fica ao seu gosto e necessidade.

Após a definição destes “parâmetros”, temos então o bloco de código que será executado. No caso acima, temos uma instrução de leitura para um vetor. Aproveitando esse exemplo falarei sobre uma peculiaridade dos vetores e matrizes na linguagem C.

Atentem, que, ao contrário do Algoritmo e da linguagem Pascal, o nosso vetor em C começa lendo a sua posição 0. Isso mesmo! Na linguagem C, os vetores e matrizes começam em sua posição 0. Ou seja, se caso declararmos um vetor

teremos um vetor com o nome vetor com dez posições: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Por isso, em nosso for, colocamos como condicional indice < 10. Quando igualar a 10, ele encerra a execução, não lendo essa posição. Caso tentarmos acessar a posição 10 desse vetor declarado com 10 posições, obteremos um erro de memória. Fica então, mais uma dica pra vocês 😉

Então, pessoas, chegamos ao fim dessa segunda parte da nossa Introdução à Linguagem C. No próximo post da série, a terceira e última parte dessa nossa introdução, veremos os registros e as funções e procedimentos na linguagem C, para então continuarmos com esses nossos estudos. Não se espantem caso encontrarem algumas coisas diferentes aqui pelo blog, pois pretendo explorar algumas coisas de Java nos próximos posts também.

Como não sei se terminarei outro post até o fim do ano, desejo a vocês, caros leitores deste blog, um ótimo Natal e um ano de 2011 repleto de realizações. Agradeço imensamente as mais de 10.000 visitas que já recebi, os e-mails e comentários de agradecimento, enfim, o crescimento no número de visitas (que foi de mais de 220% de 2009 pra 2010) e o apoio de vocês.

Abraço e até logo!

Perdeu a parte 1? Ou quer ver a parte 3?

Introdução à Linguagem C – Parte I

Pare por um instante! Após ler este post, a sua vida como programador nunca mais será a mesma… você será apresentado à linguagem considerada por alguns como A linguagem de programação… ou melhor, ela não é “A” linguagem, ela é a Linguagem C!!!!!

É, até que eu tentei fazer um início de post meio diferente do “E aí pessoal”… soou meio fantástico demais, sem ser tão fantástico assim, mas tudo bem. Valeu a intenção…

Bom, no post de hoje vamos tratar, então, de uma nova linguagem, a linguagem C. Bom, antes de começarmos a vê-la, vale nos informarmos um pouco sobre a história, origens, características e etc.

A Linguagem C é uma linguagem compilada (assim como Pascal), ou simplificadamente, o seu código, após passar pelo processo de compilação/linker, é convertido em arquivo executável. Além disso, ela é uma linguagem estruturada, ou seja, o seu código é organizado e definidos em blocos.

Ela foi criada por Dennis Ritchie em 1972, para desenvolver o Unix, que originalmente havia sido escrito em Assembly (ou Linguagem de Montagem – linguagem de programação de baixo nível, muito próxima à linguagem de máquina). Por permitir uma integração com Assembly (os códigos poderiam se misturar ao código em C), tornou-se uma das linguagens de programação mais utilizadas. Influenciou muitas linguagens, inclusive C++, que foi desenvolvida originalmente como uma extensão da linguagem C, englobando características da Programação Orientada a Objetos. Devido à sua ampla utilização, e a imensa gama de variações que foram sendo criadas ao longo de seu desenvolvimento, foi padronizada em 1999, padrão conhecido como C99. Em 2000, foi adotado como padrão ANSI. Em 2007, começou a surgir uma nova idéia de padronização, englobando novas funcionalidades à linguagem. Essa idéia é conhecida como C1X.

Bom, acho que de história isso é suficiente para o post. Quem se interessar por mais detalhes, pode acessar os links da Wikipedia que se encontram ao longo do texto.

Para programarmos, precisamos de um compilador, que irá transformar nosso código-fonte em programa. Para desenvolvermos, podemos optar por uma IDE ou Ambiente de Desenvolvimento Integrado, que reúnem ferramentas como editor de texto, compilador, depurador (debugger – permite encontrarmos erros de lógica). As opções gratuitas mais populares, sem sombra de dúvida, são Dev-C++ e Code::Blocks. Ambos os sistemas estão disponíveis para Windows e Linux. A última versão do Dev-C++ é a versão 4.9.9.2 (5.0 beta), de 2005, disponível para download aqui. Já o Code::Blocks encontra-se na versão 10.05, de maio desse ano (eles utilizam a nomenclatura de versão “Ubuntu”), que pode ser obtida aqui. Eu, particularmente, prefiro o Code::Blocks apesar dele ser um pouco mais “pesado”. Já tive problema com bugs no Dev-C++ (o que me causou algumas dores de cabeça quando desenvolvia meu projeto de 1º ano na faculdade. . .). A seguir, temos uma imagem da janela dos dois ambientes:

Tela principal do DevC++

Tela principal do Code::Blocks

A instalação dos dois ambientes é bastante tranquila e intuitiva (apesar do Code::Blocks estar disponível apenas em inglês). Qualquer dúvida, basta deixar um comentário.

Para aqueles que preferem utilizar o Linux para programar, também existem boas opções de IDE, como KDevelop e Anjuta, além dos próprios Code::Blocks e Dev-C++. Basta usar o gerenciador de pacotes de sua preferência ou baixar diretamente dos sites correspondentes e instalar. 🙂

Bom, já ficamos sabendo da história, já preparamos o nosso ambiente de programação. Mas e daí? Eu quero é programar! Como é a sintaxe dessa tal linguagem C? É totalmente diferente de Pascal? Tudo que eu já aprendi é inútil?

Calma, calma. Todos os conceitos já vistos até aqui serão utilizados e as diferenças serão explicadas. Pra começarmos, vamos ver o famoso Alô Mundo em Algoritmo, em Pascal e em C. As diferenças serão explicadas logo a seguir:

Bom, logo de cara é meio chocante, meio nada a ver com Pascal. Mas calma, é bem simples. Primeiramente, podemos ver que o nome do programa não aparece mais no código. Em C, programas podem conter vários arquivos de código, o que torna totalmente dispensável adicionar o nome do programa aos arquivos. Então, observação 1: em C, não temos o nome do programa no código. Logo em seguida, temos #include <stdio.h> que “equivale” ao uses crt. Os includes indicam arquivos de cabeçalho (daí a extensão .h – header) que contêm funções. No caso, stdio (standard in out) possui referências às funções padrão de entrada e saída. Podemos generalizar uma observação 2 dizendo que todos os programas em C terão o #include <stdio.h>. Em seguida, temos o “assustador” int main(void)! Calma, calma pessoal. Vamos explicar. Por padrão definido na linguagem, todo programa em C é composto de funções e deve conter a função main, que é a primeira função do programa, a que é chamada pelo sistema operacional quando o sistema é chamado. Tá, mas e esse tal de int main(void), o que significa. Significa o seguinte: a função de nome main devolverá um valor do tipo inteiro – int – e não receberá nada como argumento – void. O abre e fecha chaves equivale ao nosso begin / end do Pascal, ou seja, o que definimos entre eles é o que a função irá fazer. Podemos, então, definir as funções em C com o seguinte formato:

<valor de retorno> <nome da função>(<lista de argumentos>)

Aproveitando a cartada, vou falar sobre os tipos primitivos em C.

  • int – o nosso querido amigo, inteiro
  • long – o inteiro, com uma maior capacidade (para números beeeeem grandes)
  • float – o conhecido real. Chamado de float ou “ponto flutuante” porque a vírgula (ou ponto, nos EUA) “caminha” ou “flutua” (haja criatividade!)
  • double – float com maior precisão de casas após a vírgula
  • char – tipo caractere
  • void – o “nada”, “vazio”, “coisa nenhuma”… Não é usado para declarar variáveis, apenas para valores de retorno e parâmetros de funções.

Putz, acabou??? E a string??? E o booleano??? Calma, gente… C, ao contrário de Pascal (que foi desenvolvida para ser uma linguagem voltada para o ensino da programação), foi desenvolvida para fornecer flexibilidade aos programadores. String em C, são na verdades vetores de caracteres terminados com ”. Este caractere serve pra diferenciar strings de vetores de caracteres comuns. Por exemplo, uma string com o meu nome ficaria com ‘R’ ‘a’ ‘f’ ‘a’ ‘e’ ‘l’ ”, ou seja, seria um vetor de 7 posições. Já o tipo booleano só passou a existir a partir do padrão C99 (desde que seja incluído o arquivo stdbool.h), sendo então chamado de bool. Mas no geral, a linguagem C considera todo inteiro igual a 0 (zero) como falso e qualquer valor não-zero como verdadeiro.

Bom, continuando a nossa análise do nosso pequeno Alo Mundo. Logo após à declaração da função main, temos uma abre-chaves. Em C, as chaves delimitam o corpo das funções e dos laços, da mesma forma como temos o begin e o end em Pascal. Bastante simples, não? E poupa digitação, agilizando a codificação! 🙂

Prosseguindo, temos uma chamada ã função printf. Esta é a função padrão da linguagem para a escrita de texto na tela do console. Na chamada a ela, passamos uma constante de texto. Em C, as constantes de texto vem entre aspas duplas, em vez das aspas simples do Pascal. Mas o que seria esse n no final?? Em C, temos algumas constantes para a formatação de texto. n é pra pular de linha. Outra constante bastante utilizada é o t que indica uma tabulação horizontal.

Para concluirmos, temos o return 0; que indica o retorno da função (como foi declarado que a função main retorna um inteiro, precisamos retorná-lo, certo?). Mas por que 0? E pra quem estamos retornando isso? Estamos retornando 0 para o sistema operacional. O valor 0 indica que o programa executou corretamente, sem erros.

Vamos agora ver um exemplo com a função de leitura e o uso de condicionais.

Vamos começar, então, explicando o uso das condicionais. Como pode ser percebido, pouquíssima coisa muda em relação ao Pascal. não temos a palavra then após a sentença condicional e o uso dos parênteses é obrigatório. A seguir, a lista dos operadores lógicos em C, que por sua vez diferem um pouco dos já conhecidos em Pascal:

  • Igualdade: ==
  • Menor, Maior, Menor ou Igual, Maior ou Igual: <, >, <=, >=
  • Diferente: !=
  • E: &&
  • Ou: || (dois pipes, aquele símbolo geralmente Shift+Contrabarra)

Como pode ser visto, nenhuma novidade. A lógica funciona da mesma maneira: executa-se o bloco if caso a sentença seja verdadeira e o bloco else (caso exista), caso seja falsa.

Agora, vamos verificar a nossa função de leitura, a função scanf. Nesta função, passamos dois parâmetros para a mesma. Primeiramente, devemos passar o formato do conteúdo que vamos ler. Como assim??? Calma, no começo pode parecer um tanto quanto confuso, mas é mais simples do que parece. Neste primeiro parâmetro, especificamos o tipo da variável que vamos ler. Os argumentos mais comuns são:

  • “%d” ou “%i” – para o tipo int
  • “%f” para o tipo float
  • “%c” para o tipo char
  • “%s” para strings (ou melhor, vetores de caracteres char[])

Já no segundo parâmetro, passamos a variável em que queremos guardar o conteúdo lido. Mas por que esse & antes do nome da variável??? Porque na verdade estamos passando o endereço na memória desta variável. Mas não se preocupe com isso por enquanto. Essa história de endereços será vista com mais calma quando chegarmos nos famosos (e temidos) ponteiros. Logo logo a gente chega lá. Voltando ao scanf, o único tipo que não necessita do & é quando vamos ler strings (pelo fato de vetores já serem ponteiros… mais uma vez, não se preocupe com isso por enquanto!).

Bom, aqui encerro a primeira parte da Introdução à Linguagem C. Pratiquem a programação, busquem materiais diferentes (tolo é o homem de um só livro, dizia um professor do Ensino Fundamental…) e divirtam-se! Desculpem-me por esse hiato entre os posts, mas a vida de faculdade no 3º ano não está fácil. Assim que possível, posto a segunda e última parte dessa nossa introdução. No próximo post, explicarei a estrutura de seleção switch e as estruturas de repetição while, do-while e for. E quem sabe uma explicação sobre funções!

Uma última coisa antes de encerrar. Gente, por favor não fiquem pedindo programas prontos, sejam nos comentários, sejam via e-mail. Tenho recebido inúmeros e-mails com pedidos do tipo. Sinceramente, os exercícios que os professores passam no curso técnico / faculdade servem pra que vocês desenvolvam o seu raciocínio lógico. Treinar, errar, quebrar a cabeça é essencial para um bom aprendizado. Digo isso para o bem de vocês mesmos como futuros profissionais. Fica a dica!

Abraço a todos e boa programação!

Confira a parte 2 aqui e a parte 3 aqui!

Introdução à Linguagem Pascal

Olá a todos novamente!

Hoje, finalmente, iremos começar a programar de fato, e fazer o nosso primeiro programa! Quanto a linguagem, iremos utilizar a Linguagem Pascal num primeiro momento. Apesar de muitos não concordarem com o uso dela, eu a considero a melhor escolha para o ensino da programação, por ter uma sintaxe clara e fácil de ser entendida.

Para escrever e compilar (transformar o código escrito em um arquivo executável), utilizaremos o Pascal Zim, um ambiente criado pelo departamento de Ciência da Computação da Universidade de Brasília, para o auxílio no ensino da disciplina de Algoritmos. Atualmente, ele encontra-se na versão 6.0.3.1. O link para download você encontra aqui. Algumas pessoas podem preferir utilizar o Turbo Pascal, da Borland. Eu optei pelo Pascal Zim por dois motivos: a última versão do Turbo Pascal é de 1991 (ou seja, já tem 18 anos!!!) e também pelo fato do Pascal Zim ser brasileiro! (vamos valorizar os programadores do Brasil!). Caso queiram utilizar o Turbo Pascal, fiquem à vontade, pois a sintaxe é a mesma.

Após baixarem o Pascal Zim, descompacte-o utilizando o Winrar, PKZip, Winzip, 7Zip, enfim, qualquer um que você tenha aí. Logo após, vá até a pasta pascalzim e execute o Pzim.exe. Teremos a seguinte janela:

Esta é a tela de edição de um programa no Pascal Zim. É nela que escreveremos os comandos que irão compor o nosso programa. A seguir, temos um programa simples em algoritmo que iremos passar para a linguagem Pascal:

Este é um programa extremamente simples, que escreve o texto Olá, Mundo! Estou no blog do Rafael Toledo! na tela. Em Pascal, este programa ficaria dessa forma:

Vamos agora explicar passo-a-passo este primeiro programa. Na primeira linha, temos Program Ola_Mundo; Esta linha define o nome do nosso programa, da mesma forma que definimos o nome do nosso algoritmo na primeira linha dele. Perceba que, os comandos do Pascal terminam com ; e se você não colocá-los, ocorrerá um erro na hora de compilar. Logo em seguida temos o Begin, que significa o início do programa. Os comandos do nosso programa começarão a ser escritos a partir deste Begin. Ele não tem ; porque não é um comando, mas uma indicação de que a área de processamento está iniciando. A seguir, temos o comando write(‘Olá, Mundo! Estou no blog do Rafael Toledo!’); que corresponde ao Escreva(“Olá, Mundo! Estou no blog do Rafael Toledo!”). Perceba, basicamente, é a mesma coisa no algoritmo e no programa, com a diferença de que no Pascal os comandos são em inglês. Outra diferença é que na linguagem Pascal o texto deve vir entre aspas simples enquanto que no algoritmo ele vem entre aspas duplas. Também não se deve esquecer de colocar o ponto e vírgula no final do comando. Encerrando o programa, temos End. que indica o final do programa. Este End deve sempre ser acompanhado do ponto final, indicando que o programa se encerra aí.

Caso você esteja utilizando o Turbo Pascal, precisará incluir a seguinte linha depois do título do programa:

Esta linha inclui a biblioteca padrão de comandos. Caso esteja utilizando a versão para DOS do Turbo Pascal, substitua wincrt por crt. No Pascal Zim, a biblioteca é incluída automaticamente, então não há a necessidade de colocar esta linha.

Vamos agora fazer um programa simples, que recebe dois números do usuário e os soma. Primeiro, vamos fazer o algoritmo deste programa:

Um algoritmo muito simples, onde lemos o valor de duas variáveis do tipo inteiro, e depois as somamos, armazenando na variável resultado, e mostramos na tela. Agora vamos fazer o mesmo programa em Pascal:

Este programa tem alguns elementos a mais que o outro não tinha. Na primeira linha, temos o título do programa, da mesma forma como estava no Olá Mundo. Após isso, temos a área Var, onde declaramos as variáveis do tipo Inteiro, no caso da linguagem Pascal, Integer. A seguir os tipos básicos e os seus respectivos nomes na linguagem Pascal:

  • Inteiro = Integer
  • Real = Real
  • Caracter = Char
  • Booleano = Boolean
  • Literal = String

Na linguagem Pascal, todas as variáveis devem ser declaradas nesta seção. Caso queira declarar variáveis de tipos diferentes, deve-se fazer igual a um algoritmo:

Uma coisa importante que eu tinha esquecido de falar é que a linguagem Pascal não distingue maiúsculas de minúsculas. Ou seja, Real é a mesma coisa que  real ou rEaL ou reaL. Da mesma forma se você declarar uma variável Media, não poderá declarar outra com o nome de media.

Continuando o código, temos o início do programa. O primeiro comando escreve uma mensagem pedindo pra o usuário entrar com o primeiro número. Em programação, esse tipo de mensagem é conhecido como prompt. Em seguida, temos a função readln() que lê um valor do usuário e o armazena em uma variável. Depois, repetimos os dois comandos para ler o segundo número da soma. Em seguida, temos o cálculo da soma. Perceba que, na linguagem Pascal, o operador de atribuição é representado por := em vez da seta que representamos nos algoritmos. Na última linha, temos a apresentação do resultado na tela, através da função write(), onde colocamos entre os parênteses o texto e  a variável que queremos exibir na tela.

Para concluir este primeiro post, vamos fazer um último programa que calcula a sua idade, baseando-se no seu ano de nascimento, utilizando o conceito de constantes. Teremos, então o seguinte algoritmo:

Passando este algoritmo para a linguagem Pascal, teremos o seguinte:

Basicamente, temos apenas um detalhe novo em relação ao último programa: a inclusão da área Const para a declaração de constantes. A declaração ocorre da mesma forma que nos algoritmos, ou seja, sem a definição do tipo, utilizando o operador = para indicar o valor da constante. Outro detalhe é a utilização da função writeln(). Mas qual a diferença entre write() e writeln()? Ao utilizar a função write(), o cursor ficará posicionado logo após o final do texto. Já na função writeln(), o cursor pulará para a próxima linha ao escrever o texto. O emprego dessas funções deve priorizar a estética na tela, deixando o programa com um visual mais “agradável”.

Para encerrar este tópico, vou deixar alguns exercícios para praticarem a elaboração de algoritmos e a programação em Pascal:

1. Desenvolva um algoritmo para calcular a média de 4 números fornecidos pelo usuário.

2. Desenvolva um algoritmo para calcular a expressão S = (A + B) / (A – B).Os valores A e B deverão ser fornecidos pelo usuário.

3. Desenvolva um algoritmo para calcular o volume de um cilindro, dado por Pi R² H, onde R é o raio, H é a altura e Pi uma constante equivalente a 3,14. Os valores de R e H deverão ser fornecidos pelo usuário.

4. Desenvolva um algoritmo para calcular a área da esfera, dada por 4 Pi R² e o seu volume, dado por 4 Pi R³ / 3, onde R é o raio e Pi uma constante equivalente a 3,14. O valor de R deverá ser fornecido pelo usuário.

5. Desenvolva um algoritmo para calcular a altura do cilindro, dada por V / 4 Pi R², onde R é o raio, V é o volume e Pi uma constante equivalente a 3,14. Os valores R e V deverão ser fornecidos pelo usuário.

6. Desenvolva um algoritmo para calcular a função F(x,y) = 2x + 2y², em um domínio real. Os valores X e Y deverão ser fornecidos pelo usuário.

7. Desenvolva um algoritmo para calcular o troco a ser devolvido a um cliente. Deve ser lido (fornecido pelo usuário) o valor  a ser pago e o valor dado pelo cliente.

8. Desenvolva um algoritmo para calcular o valor absoluto da diferença entre A e B. Os valores A e B deverão ser lidos.

9. Desenvolva um algoritmo para calcular (converter) graus Farenheit (F) em graus Centígrados (C) , utilizando a seguinte fórmula: C = 5 (F – 32) / 9. O valor F deverá ser lido.

Algumas dicas:
– Função para calcular a raiz quadrada: sqrt(número)
– Função para calcular o valor absoluto de um número: abs(número)

Tentem fazer os exercícios. Qualquer dúvida, postem nos comentários. No próximo post colocarei as respostas dos exercícios e as respectivas implementações em Pascal.

Abraço a todos e bom feriado!