ATIVIDADES PRÁTICAS

SUPERVISIONADAS

Tecnologia em Análise e Desenvolvimento de Sistemas

2ª Série
Laboratório de Programação Estruturada

A atividade prática supervisionada (ATPS) é um método de ensino-

aprendizagem desenvolvido por meio de um conjunto de atividades
programadas e supervisionadas e que tem por objetivos:
Favorecer a aprendizagem.
Estimular a co-responsabilidade do aluno pelo aprendizado eficiente e
eficaz.
Promover o estudo, a convivência e o trabalho em grupo.
Desenvolver os estudos independentes, sistemáticos e o autoaprendizado.
Oferecer diferenciados ambientes de aprendizagem.
Auxiliar no desenvolvimento das competências requeridas pelas Diretrizes
Curriculares Nacionais dos Cursos de Graduação.
Promover a aplicação da teoria e conceitos para a solução de problemas
relativos à profissão.
Direcionar o estudante para a emancipação intelectual.
Para atingir estes objetivos as atividades foram organizadas na forma de
um desafio, que será solucionado por etapas ao longo do semestre letivo.
Participar ativamente deste desafio é essencial para o desenvolvimento das
competências e habilidades requeridas na sua atuação no mercado de trabalho.
Aproveite esta oportunidade de estudar e aprender com desafios da vida
profissional.

AUTOR(ES):
Marcelo Augusto Cicogna – FAV
Jeanne Dobgenski – AESA
Jaqueline Brigladori Pugliesi – FAV/FAC2
Tecnologia em Análise e Desenvolvimento de Sistemas – 2ª Série – Laboratório de Programação Estruturada

COMPETÊNCIAS E HABILIDADES

Ao concluir as etapas propostas neste desafio você terá desenvolvido as competências

e habilidades descritas a seguir.
Compreender tecnologias relacionadas à comunicação e processamento de dados e
informações.

DESAFIO

Muitos programas de computador do tipo “Console” são utilizados todos os dias. Para a
plataforma Linux, esta é uma afirmação quase que incorporada à estrutura do próprio
Sistema Operacional (SO). No SO Windows, os aplicativos de console, que são simples em
interface, mas que desempenham tarefas muitas vezes sofisticadas, não são tão comuns à
experiência típica de uso do sistema. Por exemplo, pode-se citar desde programas de linha de
comando como “ipconfig” que auxilia na visualização das configurações de rede de um PC,
até programas como o “taskkill” que auxiliam o usuário a eliminar processos ativos na
memória do computador.

O objetivo desta atividade é motivar o aluno a adquirir experiência com o ciclo completo de
desenvolvimento de um pequeno aplicativo de linha de comando (Console). Este ciclo
utilizará os conceitos apresentados na disciplina de algoritmos; apresentará um exemplo de
organização e de documentação de código fonte; exigirá uma organização funcional do
código baseado em estruturas modulares; por fim, o aluno implementará um software de
linha de comando com opções de parâmetros na chamada do programa.

Esta tarefa deverá ser implementada utilizando-se a Linguagem C. Sugere-se como

compilador e interface de desenvolvimento o Code::Blocks (disponível no seguinte endereço:
<www.codeblocks.org>).

O Problema
Esta atividade concentra esforços no desenvolvimento de um programa que permita contar
linhas de código fonte desenvolvido em Linguagem C ou C++. A estrutura sugerida
permitirá a sua adequação para outras linguagens. Escolheu-se este tema por se tratar de um
problema de simples entendimento, deixando espaço para que o aluno concentre o
desenvolvimento de suas habilidades no entendimento e prática do ciclo de criação e
implementação do aplicativo.

A contagem de linhas de um arquivo texto pode ser facilmente desenvolvida em poucas

linhas de código, conforme apresentado no exemplo da Listagem 1.

2 Marcelo Augusto Cicogna, Jeanne Dobgenski, Jaqueline Brigladori Pugliesi

 Tecnologia em Análise e Desenvolvimento de Sistemas – 2ª Série – Laboratório de Programação Estruturada

Listagem 1. Exemplo de programa em Linguagem C para contagem de linhas de um arquivo.

#include <stdio.h>

int main ()
{
FILE * pFile;
int c;
int n = 0;
pFile = fopen ("ArquivoTexto.txt", "r");
if (pFile !=NULL)
{
do { //DO
c = fgetc(pFile);
if (c == '\n') n++;
} //DO
while (c != EOF);
fclose(pFile);
printf("Número de linhas = %d.\n", n);
}
return 0;
}

O Desafio
Partido do exemplo anterior de contagem simples de linhas de um arquivo texto, o desafio
desta tarefa tem início ao se querer determinar o número de linhas do código que são
comentários formatados segundo a sintaxe da Linguagem C/C++. A sintaxe prevê dois tipos
de comentários: linha única começando com os caracteres “//” (barra, barra); e comentários
multi-linhas começando com “/*” (barra, asterisco) e com término determinado por “*/”
(asterisco, barra).

Para uma visão de um problema real, considere o exemplo de código fonte escrito em C
apresentado na Listagem 2. Observe os vários trechos com comentários para ajudar a
documentação do código-fonte.

Listagem 2. Exemplo real de código fonte com vários comentários.

//------------------------------------------------------------------------------
// Exemplo de Cabeçalho
//
// Neste tipo de comentário, faz-se uma breve apresentação do conteúdo do
// módulo em linguagem C. O código apresentado a seguir é um extrato de
// desenvolvimento criado para a disciplina de Classificação e Pesquisa.
// Pede-se ao leitor identificar os tipos de linhas com comentários, em
// especial a diferenciação de comentários de uma ou de várias linhas.
//
// Autor: Marcelo Augusto Cicogna.
// Revisões:
// 22/11/2005: Criação do módulo.
// 01/11/2006: Expansão do módulo em função da lista de exercícios.
//------------------------------------------------------------------------------
#include "TBinTree.h"

#include <stdio.h>
//------------------------------------------------------------------------------
// Funcões de manipulação do tipo TBinTree.
//------------------------------------------------------------------------------
TBinTree*
binTreeCreate(TData* pData)
/** Função para criação de uma nova árvore binária. É necessário fornecer um
valor para o primeiro nó.
@param pData variável do tipo TData para compor o nó raíz (root).

3 Marcelo Augusto Cicogna, Jeanne Dobgenski, Jaqueline Brigladori Pugliesi

Tecnologia em Análise e Desenvolvimento de Sistemas – 2ª Série – Laboratório de Programação Estruturada

@return ponteiro para uma árvore binária.

@see BinTree.#dataCopy dataCopy()
@version 1.01
@author Marcelo Augusto Cicogna
*/
{
TBinTree* binTree = malloc(sizeof(TBinTree));
if (binTree != NULL)
{ //Alocação do node raíz.
TNodeBin* pNode = nodeCreate();
//Copia no novo nó o valor data passado como parâmetro.
dataCopy(pNode->pData, pData);
//Associa o novo nó ao root da árvore binária.
binTree->root = pNode;
}
return (binTree);
}
//------------------------------------------------------------------------------
void
binTreeInsertNode(TNodeBin* pNode, TData* pData)
/** Função para inserção de um novo nó em uma árvore binária.
Função recursiva por meio do parâmetro pNode.
@param pNode ponteiro para um nó da árvore binária.
@param pData ponteiro para uma variável do tipo TData a ser inserida.
@return Não há retorno
@see BinTree.#dataCopy dataCopy()
@version 1.01
@author Marcelo Augusto Cicogna
*/
{
TNodeBin* pNodeAux;
if (pNode != NULL)
{ //Se for para inserir do lado esquerdo.
if ( dataComp(pData, pNode->pData, 0) < 0 )
{ //Inserir se o arco esquerdo for nulo.
if (pNode->esq == NULL)
{
pNodeAux = nodeCreate(); //Este é um exemplo de comentário
dataCopy(pNodeAux->pData, pData); //que ocorre junto com código.
pNode->esq = pNodeAux; //Será necessário um tratamento.
}
//Caso contrário, tentar inserir na sub-árvore a esquerda (recursivo).
else
binTreeInsertNode(pNode->esq, pData);
}
//Se for para inserir do lado direito.
else
{ //Inserir se o arco direito for nulo.
if (pNode->dir == NULL)
{
pNodeAux = nodeCreate();
dataCopy(pNodeAux->pData, pData);
pNode->dir = pNodeAux;
}
//Caso contrário, tentar inserir na sub-árvore a direita (recursivo).
else
binTreeInsertNode(pNode->dir, pData);
}
}
}
//------------------------------------------------------------------------------

Como resultado a ser conquistado, espera-se poder utilizar um aplicativo auxiliar para contar
as linhas do arquivo “Exemplo.c” (ou de outro que o aluno achar conveniente durante a fase
de testes). Veja um exemplo do provável funcionamento de tal programa.

4 Marcelo Augusto Cicogna, Jeanne Dobgenski, Jaqueline Brigladori Pugliesi

 Tecnologia em Análise e Desenvolvimento de Sistemas – 2ª Série – Laboratório de Programação Estruturada

Figura 1. Exemplo de uso e funcionamento do contador de linhas de código fonte.

Note-se que o programa “CodeCount” possui um parâmetro “–c” ou “-comment” que

permite ao usuário decidir a contagem, ou não, das linhas com comentários. Vale lembrar
que no arquivo Exemplo.c, existe uma linha vazia entre os dois “#include”. Além disso, as
linhas que terminam um comentário multi-linhas com “*/” não são contadas como linhas em
branco, mas também não são contadas como linhas de comentário.

Permite-se aos alunos e professores encontrarem outras regras de contagem. Esta atividade
adotou algumas regras, mas elas não precisam ser as únicas durante a fase de
desenvolvimento.

Equipe
As etapas descritas à seguir devem ser realizadas em grupos de até quatro alunos.

ETAPA 1

Aula tema: Modularização: uso de funções. Passagem de parâmetros: por valor.

Exercícios. Modularização: uso de funções. Passagem de parâmetros: por referência.
Exercícios.

Esta atividade é importante para que você compreenda os requisitos do problema e

determine uma organização inicial do código fonte que permita o desenvolvimento de uma solução.
Para realizá-la é importante seguir os passos descritos.

PASSO 1

Leia atentamente o desafio e os conceitos de contagem de linhas. Identifique os dois

tipos principais de comentários possíveis em linguagem C: comentário de uma linha apenas,
que começa com “//”; e comentários multi-linhas determinado por “/*” e “*/”.

PASSO 2

Analise o problema e faça sugestões de como organizar o código em uma função

principal (main) e uma outra função que fará a contagem das linhas dado como parâmetro o
nome do arquivo a ser pesquisado. Pode-se chamar esta função de ccRun.

5 Marcelo Augusto Cicogna, Jeanne Dobgenski, Jaqueline Brigladori Pugliesi

Tecnologia em Análise e Desenvolvimento de Sistemas – 2ª Série – Laboratório de Programação Estruturada

Observação: ao utilizar o prefixo “cc” (de Code Count), ou qualquer outro que o aluno
achar conveniente, facilita-se a integração do código desenvolvido nesta tarefa com outras
que o programador venha a achar necessário no futuro.
Como guia para alunos e professores, os autores deste desafio determinaram dois
módulos para a solução do problema.
O módulo principal foi denominado MainCodeCount e um módulo auxiliar com
funções de auxílio ao principal chamado LibCodeCount. Ao mesmo tempo, foram projetadas
duas funções, conforme a orientação anterior. Os cabeçalhos e os nomes dos arquivos os
quais conterão o código fonte são apresentados na Figura 2.

Arquivo MainCodeCount.c
int main(int argc, char *argv[])
{...
}

Arquivo LibCodeCount.h
void ccRun(char* file, int* nLines, int* nLinesComment, int* nLinesEmpty,
int noComment, int silent);

Arquivo LibCodeCount.c
void
ccRun(char* file, int* nLines, int* nLinesComment, int* nLinesEmpty,
int noComment, int silent);
{...
}

Figura 2. Exemplo de uso e funcionamento do contador de linhas de código fonte.

Estude a modularização proposta. É importante que seu código siga a organização

sugerida nesta atividade, ou seja, que possua pelo menos dois módulos: um principal e outro
auxiliar. Não será aceito na avaliação desta etapa a apresentação de apenas um arquivo de
código fonte (arquivo.c).

PASSO 3

O grupo deverá entregar o código fonte formado por dois módulos que contenham a
função principal e uma função auxiliar para o cálculo do número de linhas, considerando as
opções fornecidas nesta etapa.

ETAPA 2

Aula tema: Ponteiros e sua aplicação. Arquivos. Uso avançado de vetores e matrizes.
Exercícios.

Esta atividade é importante para que você entenda a passagem de parâmetros para um
programa escrito em linguagem C.
Para realizá-la é importante seguir os passos descritos.

6 Marcelo Augusto Cicogna, Jeanne Dobgenski, Jaqueline Brigladori Pugliesi

 Tecnologia em Análise e Desenvolvimento de Sistemas – 2ª Série – Laboratório de Programação Estruturada

PASSO 1

Pesquise a utilização dos argumentos “argc” e “argv” passados como parâmetros da

função principal “main()” de um programa escrito em linguagem C.

PASSO 2

Elabore uma função principal que aceite os seguintes parâmetros:

Parâmetro obrigatório.
“Nome do arquivo”. O primeiro parâmetro será o nome de um arquivo a ser
pesquisado o número de linhas.

Parâmetros opcionais.
-h (-help) opção para apresentar uma explicação do uso do programa CodeCount.
-c (-comment) opção para contar o número de linhas de comentários.
-s (-silent) opção para não apresentar resultados na tela de comando (prompt).

Para auxílio dos alunos, apresenta-se um exemplo na Listagem 3 de como criar o

parâmetro “–s”. Neste exemplo será possível notar o uso dos argumentos “argc” e “argv”.
Vale lembrar que a posição zero do vetor “argv” possui sempre o nome do programa, neste
caso “CodeCount”.
Como se trata de criar uma forma de implementar os parâmetros opcionais, o loop pelo
arquivo “argv” começa na posição 2, uma vez que a posição 1 foi reservada para conter o
nome do arquivo a ser pesquisado. Assim, a chamada do programa (o símbolo “>”
representa a linha de comando, ou prompt do sistema operacional):

> CodeCount Exemplo.c –c

Teria os seguintes argumentos passados para a função principal:

argc = 3
argv[0] = “CodeCount”
argv[1] = “Exemplo.c”
argv[2] = “-c”

Listagem 3. Exemplo de função principal com gerenciamento de parâmetros.

int
main(int argc, char *argv[])
{
int i, silent;
int nLines, nLinesComment, nLinesEmpty, count;
silent = 0;
nLines = 0;

for (i=2; i<argc; i++)

{
silent = silent || (strstr(argv[i], "-silent" ) != NULL);
silent = silent || (strstr(argv[i], "-s" ) != NULL);
}
printf("Code Count - Programmer's Tool\n");
printf(" Version 1.1 - 2009\n\n");

if (!silent)
{
printf(" counting for \"%s\"...\n", argv[1]);
}

7 Marcelo Augusto Cicogna, Jeanne Dobgenski, Jaqueline Brigladori Pugliesi

Tecnologia em Análise e Desenvolvimento de Sistemas – 2ª Série – Laboratório de Programação Estruturada

ccRun(argv[1], &nLines, &nLinesComment, &nLinesEmpty, noCom, silent);

Note que o exemplo testa se o usuário passou a versão curta do parâmetro “-s” ou a
versão normal “-silent”.

PASSO 3

O grupo deverá entregar o código fonte, em complemento ao que foi entregue na

etapa anterior, que apresente uma função principal capaz de processar os parâmetros e
opções estabelecidos nesta etapa.

ETAPA 3

Aula tema: Ponteiros e sua aplicação. Uso avançado das estruturas. Exercícios.
Arquivos. Uso avançado de vetores e matrizes.

Esta atividade é importante para que você determine a versão final do programa capaz de
contar linhas e comentários, bem como utilizar a passagem de parâmetros projetada na etapa anterior.
Para realizá-la é importante seguir os passos descritos.

PASSO 1

Nesta etapa, será necessário entender o conteúdo de um arquivo texto e elaborar uma
estratégia para a contagem de linhas, principalmente focando o problema de contagem de
linhas com comentários.
Por exemplo, a leitura de um arquivo texto pode ser interpretada como o percurso por
um vetor de caracteres. Como ilustração desta idéia, veja o arquivo abaixo:

Arquivo
Segunda linha
fim

A leitura deste arquivo no disco pode ter uma representação da seguinte forma:

A r q u i v o \n S e g u n d a l i n h a \n f i m EOF

Note que as linhas têm o caractere especial ‘\n’ para delimitar o seu fim, bem como o
final do arquivo é encontrado quando se processa a informação EOF (End Of File).
A idéia para a contagem de linhas, conforme visto na Etapa 1, baseia-se na contagem
dos caracteres ‘\n’ de um arquivo texto.
Ao mesmo tempo, a contagem de linhas com comentários pode fazer uso da mesma
estratégia.
Por exemplo, o uso de variáveis auxiliares, pode-se determinar a ocorrência dos
caracteres “\\”, indicando que esta linha é um comentário e que, portanto, ao encontrar um
caractere ‘\n’ esta linha deva ser contada como comentário.

8 Marcelo Augusto Cicogna, Jeanne Dobgenski, Jaqueline Brigladori Pugliesi

 Tecnologia em Análise e Desenvolvimento de Sistemas – 2ª Série – Laboratório de Programação Estruturada

O mesmo vale para comentários multi-linhas. Ao se identificar os caracteres “/*”

todos os caracteres ‘\n’ encontrados antes da ocorrência de “*/” deverão ser contabilizados
como linhas de comentário.

PASSO 2

Desenvolva um algoritmo que baseado na leitura caractere a caractere de um arquivo

texto, contabilize o número de linhas total, o número de linhas de comentário simples e o
número de linhas de comentário multi-linhas.
Por exemplo, considere o arquivo:

// Este é um comentário de uma linha só.

for (i = 0; i < 10; i++)
{
/* Este é um comentário de duas linhas.
O término é ocorre na próxima linha.
*/
printf(“Valor de i %d”, i); //Um comentário aqui não deve ser computado.
}

Este arquivo possui 8 linhas. Uma linha é do tipo comentário simples, iniciado com
“//”. Duas linhas possuem comentário multi-linhas. Neste caso, não foi contabilizada a linha
com o “*/”, mas os alunos podem encontrar outra regra. É importante notar que o
comentário apresentado após o comando “printf” não deve ser contabilizado, uma vez que a
mesma linha possui código.

PASSO 3

O grupo deverá entregar o código fonte, em complemento ao que foi entregue na

etapa anterior, que apresente uma função principal capaz de contabilizar o número de linhas
total de um arquivo de código fonte em linguagem C. Em complemento, o programa deve
também contabilizar o número de linhas com comentários simples, multi-linhas e o número
de linhas “em branco” (sem comentários e/ou instruções de código).

ETAPA 4

Aula tema: Arquivos. Uso avançado de vetores e matrizes.

Esta atividade é importante para que você valide o programa desenvolvido.

Para realizá-la é importante seguir os passos descritos.

PASSO 1

Crie três tipos de arquivos de código fonte escritos em Linguagem C. Por exemplo,
crie um arquivo com poucos comentários, fáceis de serem identificados. Os outros dois
arquivos podem possuir um numero maior de combinações e linhas de comentários. Veja,
por exemplo, o código apresentado na Listagem 2.

9 Marcelo Augusto Cicogna, Jeanne Dobgenski, Jaqueline Brigladori Pugliesi

Tecnologia em Análise e Desenvolvimento de Sistemas – 2ª Série – Laboratório de Programação Estruturada

Demonstre o uso do programa desenvolvido, bem como os resultados obtidos. Tenha

como objetivo apresentar ao usuário um documento simples que demonstre que seu
programa funciona bem e que determina os resultados esperados.

PASSO 2

O grupo deverá entregar um relatório simples que apresente o funcionamento do

programa e que demonstre os resultados apontados neste desafio. É importante que os
alunos explorem vários tipos de arquivos de código fonte, validando a contagem de
comentários inseridos no código fonte destes arquivos.

10 Marcelo Augusto Cicogna, Jeanne Dobgenski, Jaqueline Brigladori Pugliesi