Programming Diary

Iniciado o modulo 8, Conceitos avançados de programação, começamos a usar a parte gráfica da programação (GUI) e foi hora de começar a aprender QT, o framework escolhido para começar a desenvolver capacidades na construcao das interfaces gráficas. A linguagem utilizada é o C++ e o QT é uma framework/API baseada na filosofia open source que torna mais fácil a programação gráfica com uma potencialidade incrível.

Quem quiser saber mais sobre QT pode visitar o site: http://trolltech.com

Agora que a experiencia ja comecou, ja realizei um pequeno programa a sugestao do professor durante a aula, o qual vou partilhar de seguida:

/* Inclusao de todas as classes necessarias para o uso dos objectos */
#include <QApplication>
#include <QLabel>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QWidget>
#include <QSpacerItem>
#include <QSpinBox>
#include <QSlider>
#include <QPushButton>

int main(int argc, char *argv[]){
    /* Todas as variaveis necessarias para a interface grafica(objectos) */
    QApplication app(argc, argv);
    QWidget *janela = new QWidget;
    QLabel *dia1 = new QLabel("SEG");
    QLabel *dia2 = new QLabel("TER");
    QLabel *dia3 = new QLabel("QUA");
    QLabel *dia4 = new QLabel("QUI");
    QLabel *dia5 = new QLabel("SEX");
    QLabel *dia6 = new QLabel("SAB");
    QLabel *dia7 = new QLabel("DOM");
    QSpinBox *sbdia1 = new QSpinBox;
    QSpinBox *sbdia2 = new QSpinBox;
    QSpinBox *sbdia3 = new QSpinBox;
    QSpinBox *sbdia4 = new QSpinBox;
    QSpinBox *sbdia5 = new QSpinBox;
    QSpinBox *sbdia6 = new QSpinBox;
    QSpinBox *sbdia7 = new QSpinBox;
    QSlider *sliderdia1 = new QSlider(Qt::Horizontal);
    QSlider *sliderdia2 = new QSlider(Qt::Horizontal);
    QSlider *sliderdia3 = new QSlider(Qt::Horizontal);
    QSlider *sliderdia4 = new QSlider(Qt::Horizontal);
    QSlider *sliderdia5 = new QSlider(Qt::Horizontal);
    QSlider *sliderdia6 = new QSlider(Qt::Horizontal);
    QSlider *sliderdia7 = new QSlider(Qt::Horizontal);
    QVBoxLayout *diasdasemana = new QVBoxLayout;
    QVBoxLayout *spinboxes = new QVBoxLayout;
    QVBoxLayout *sliders = new QVBoxLayout;
    QVBoxLayout *layout = new QVBoxLayout;
    QHBoxLayout *Hcontainer = new QHBoxLayout;
    QSpacerItem *spacer = new QSpacerItem(400, 0);
    QPushButton *botaoSair = new QPushButton("Sair");

    /*Alteracao das propriedades das SpinBox e dos Sliders
     para que exista um limite minimo e maximo*/
    sliderdia1->setRange(1,5);
    sbdia1->setRange(1, 5);
    sliderdia2->setRange(1,5);
    sbdia2->setRange(1, 5);
    sliderdia3->setRange(1,5);
    sbdia3->setRange(1, 5);
    sliderdia4->setRange(1,5);
    sbdia4->setRange(1, 5);
    sliderdia5->setRange(1,5);
    sbdia5->setRange(1, 5);
    sliderdia6->setRange(1,5);
    sbdia6->setRange(1, 5);
    sliderdia7->setRange(1,5);
    sbdia7->setRange(1, 5);

    /* Ligaçao entre as SpinBox e os sliders e vice-versa; Funcionalidade do botao sair*/
    QObject:: connect(botaoSair, SIGNAL(clicked() ), &app, SLOT( quit() ) );
    QObject:: connect(sliderdia1, SIGNAL(valueChanged(int) ), sbdia1, SLOT( setValue(int) ) );
    QObject:: connect(sliderdia2, SIGNAL(valueChanged(int) ), sbdia2, SLOT( setValue(int) ) );
    QObject:: connect(sliderdia3, SIGNAL(valueChanged(int) ), sbdia3, SLOT( setValue(int) ) );
    QObject:: connect(sliderdia4, SIGNAL(valueChanged(int) ), sbdia4, SLOT( setValue(int) ) );
    QObject:: connect(sliderdia5, SIGNAL(valueChanged(int) ), sbdia5, SLOT( setValue(int) ) );
    QObject:: connect(sliderdia6, SIGNAL(valueChanged(int) ), sbdia6, SLOT( setValue(int) ) );
    QObject:: connect(sliderdia7, SIGNAL(valueChanged(int) ), sbdia7, SLOT( setValue(int) ) );
    QObject:: connect(sbdia1, SIGNAL(valueChanged(int) ), sliderdia1, SLOT( setValue(int) ) );
    QObject:: connect(sbdia2, SIGNAL(valueChanged(int) ), sliderdia2, SLOT( setValue(int) ) );
    QObject:: connect(sbdia3, SIGNAL(valueChanged(int) ), sliderdia3, SLOT( setValue(int) ) );
    QObject:: connect(sbdia4, SIGNAL(valueChanged(int) ), sliderdia4, SLOT( setValue(int) ) );
    QObject:: connect(sbdia5, SIGNAL(valueChanged(int) ), sliderdia5, SLOT( setValue(int) ) );
    QObject:: connect(sbdia6, SIGNAL(valueChanged(int) ), sliderdia6, SLOT( setValue(int) ) );
    QObject:: connect(sbdia7, SIGNAL(valueChanged(int) ), sliderdia7, SLOT( setValue(int) ) );

    /*Organizacao da disposicao de todos os objectos na janela*/
    diasdasemana->addWidget(dia1);
    diasdasemana->addWidget(dia2);
    diasdasemana->addWidget(dia3);
    diasdasemana->addWidget(dia4);
    diasdasemana->addWidget(dia5);
    diasdasemana->addWidget(dia6);
    diasdasemana->addWidget(dia7);
    spinboxes->addWidget(sbdia1);
    spinboxes->addWidget(sbdia2);
    spinboxes->addWidget(sbdia3);
    spinboxes->addWidget(sbdia4);
    spinboxes->addWidget(sbdia5);
    spinboxes->addWidget(sbdia6);
    spinboxes->addWidget(sbdia7);
    sliders->addWidget(sliderdia1);
    sliders->addWidget(sliderdia2);
    sliders->addWidget(sliderdia3);
    sliders->addWidget(sliderdia4);
    sliders->addWidget(sliderdia5);
    sliders->addWidget(sliderdia6);
    sliders->addWidget(sliderdia7);
    Hcontainer->addLayout(diasdasemana);
    Hcontainer->addLayout(spinboxes);
    Hcontainer->addLayout(sliders);
    layout->addLayout(Hcontainer);
    layout->addWidget(botaoSair);
    layout->addItem(spacer);

    /*Mostrar a janela final ( Widget ) */
    janela->setLayout(layout);
    janela->setWindowTitle("Dias da Semana");
    janela->show();
    return app.exec();
}

Segue-se o screenshot da aplicacao em funcionamento:

Agora que começou o modulo VIII que aborda a programação em interface gráfica.

Visto que nos foi pedido para realizar uma apresentação sobre esse mesmo assunto, deparei com o OpenOffice.org Impress, o qual não tinha modelos suficientes e com certeza não agradáveis para uma apresentação. De tal forma que procurei no nosso amigo Google e encontrei alguns modelos que partilho no link de seguida. Bom Proveito!

http://www.kde-files.org/?xcontentmode=632

(sujeito a atualizacao!)

Concluído o primeiro modulo deste ano lectivo está na altura de redigir uma reflexão sobre o mesmo.

Neste modulo abordamos o tratamento de ficheiros de texto maioritariamente e no final tratamos ficheiros binarios.

Falamos nas funções fopen e fclose, que servem para abrir e fechar ficheiros, tanto binários como de texto. Contudo, para abrir um ficheiro binario temos que adicionar a letra “b” ao modo de abertura do ficheiro.

Depois falamos da insercao e leitura de dados do ficheiro caracter a caracter, a qual ja abordei aqui no blog. Mais tarde passamos a fazer a insercao de dados no ficheiro com o fprintf() que permite utilizar o printf normal, mas a escrever no ficheiro. O mesmo se passa com o fscanf() que le dados a partir do ficheiro.

Por fim quando abordamos os ficheiros binários. Aprendemos a inserir variáveis no ficheiro binário e a retirá-las usando as funções fwrite() e fread().

Eu nao tive qualquer difuldade neste modulo e consegui tirar a nota maxima em ambas as provas praticas. Vou continuar empenhando nos proximos modulos!

Hoje foi o dia em que se concretizou a primeira avaliação do modulo através de uma prova pratica. Como tal, tivemos que executar uma serie de exercícios de dificuldade baixa e média para obter uma classificação positiva. Por fim, houve um exercício mais complicado para obter a nota máxima. É deste ultimo que vou falar.

Como ainda sobrou tempo ao terminar o ultimo exercício resolvi publicar no blog o mesmo a sugestão do professor.

Este programa esta escrito em linguagem C. O mesmo abre um ficheiro de origem passado por parâmetros. Caso o ficheiro de destino também seja especificado nos parâmetros, este será utilizado, caso contrario o ficheiro de destino será default.txt. A função do programa é fazer a copia do ficheiro de origem eliminando todas as linhas começando pelo carácter #(cardinal), também conhecidos como comentários. Todas estas linhas são escritas num ficheiro de log chamado nocomments.log e por fim o programa diz o numero de linhas que foram eliminadas.

Segue-se o código:

Nota: Qualquer erro na compilação e provavelmente devido à falta do caracter pois o mesmo desaparece por causa da formatação do wordpress.

#include <stdio.h>

int main(int argc, char *argv[]){
    FILE *origem, *destino, *logfile;
    char prevchar = '\n', c, buffer[100];
    int k, linhas = 0, j = 0;

    if(argc < 2 || argc > 3){
        printf("utilizacao: origem [destino]\n");
        printf("origem: ficheiro a ser processado(obrigatorio)\n");
        printf("destino: ficheiro gerado(opcional)\n");
        return 1;
    }

    logfile = fopen("nocomments.log" ,"w");
    origem = fopen(argv[1], "r");
    if(origem == NULL){
        printf("Ficheiro de origem inexistente. Impossivel executar a aplicacao\n");
        return 1;
    }
    if(argv[2] != NULL){
        destino = fopen(argv[2], "r");
        if(destino == NULL)
            destino = fopen(argv[2], "w");
        else{
            printf("Ficheiro de destino ja existe. Pretende escrever por cima?\n");
            printf("(1) Sim\n");
            printf("(2) Nao\n");
            scanf("%d" ,&k);
            if(k == 1)
                destino = fopen(argv[2], "w");
            else{
                printf("Impossivel executar a operacao. A sair.\n");
                return 1;
            }
        }

    }

    else
        destino = fopen("default.txt" ,"w");

    while((c = fgetc(origem)) != EOF){
        if(c == '#' && prevchar == '\n'){
            buffer[j] = c;
            j++;
            while((c = fgetc(origem)) != '\n'){
                buffer[j] = c;
                j++;
            }
            buffer[j] = '';
            linhas++;
            fprintf(logfile, "%s", buffer);
            fputc('\n', logfile);
            j = 0;
        }
        else
            fputc(c, destino);
        prevchar = c;
    }
    printf("Numero de linhas eliminadas: %d\n", linhas); 

    fclose(origem);
    fclose(destino);
    fclose(logfile);
    return 0;
}

Com o novo ano lectivo(2008/09) também começa a nova “temporada” da disciplina de PSI. Como PSI significa Programação de Sistemas de Informação, os assuntos abordados dizem respeito à Programação.

Este ano tudo começa com a manipulação de ficheiros na linguagem C, o Módulo 7.

O módulo está dividido entre manipulação de ficheiros de texto simples e ficheiros binários. Como o mesmo ainda vai a meio apenas irei falar sobre manipulação de ficheiros de texto. Contudo, irei também avaliar o meu próprio trabalho ao longo do modulo conforme as dificuldades existentes e o cumprimento das tarefas propostas.

De certa forma, o módulo foi bastante simples pois a forma de abordar os problemas era a mesma, mudando apenas o sitio onde manipulamos a informação. Passando do Stdout(Standard output), a consola do sistema operativo, aos ficheiros, apenas tivemos que aprender a abrir e fechar os ficheiros e algumas funções básicas para inserção e leitura de texto.

Agora que está por perto a avaliação desta parte do módulo este post funciona também como uma reflexão de como correu até agora. Sendo assim, só tenho a dizer que não tive dificuldades em nada que crie problemas ao cumprimento de todas as tarefas da aula.

Ao longo das fichas de trabalho resolvidas nas aulas, fomos aprendendo sempre mais sobre o potencial dos ficheiros. Começamos por abrir e fechar ficheiros em vários modos de acesso, depois inserimos e fizemos a leitura de texto no ficheiro através da abordagem caracter-a-caracter. Por esta altura já temos exercícios propostos para encriptação e desencriptação de ficheiros, os quais eu já terminei com sucesso e irei mostrar a seguir.

O programa recebe os parâmetros -c (para encriptar) e o -d (para desencriptar), seguido do nome do ficheiro e pela chave de encriptação. Esta deverá ser um numero inteiro que será a unica forma de encriptar ou desencriptar com sucesso. Encriptar com a chave 10, por exemplo, apenas irá permitir a desencriptação caso se use a chave 10.

O programa compila perfeitamente em Debian Linux/GNU com o compilador gcc(ou cc) com os parâmetros seguintes:

gcc -Wall codigofonte.c -o programa

/*Declaracao das bibliotecas necessárias.*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
    FILE *file1;
    int delta, k = 0;
    char c, buffer[512];

    /*Verificação se os parâmetros estão correctos ou se foi chamada a ajuda*/
    if((argc != 4) || (strcmp(argv[1],"-help") == 0)){
        printf("Utilizacao: -c|-d <filename> <chave>\n");
        printf("-c: \t\t Encripta o ficheiro\n");
        printf("-d: \t\t Desencripta o ficheiro\n");
        printf("filename: \t Nome do ficheiro a processar\n");
        printf("chave: \t Chave na qual depende o processo de encriptacao\n");
        return 0;
    }

    /* Verificação do ficheiro quanto à sua existência. */
    file1 = fopen(argv[2], "r");
    if(file1 == NULL){
        printf("[%s]: Ficheiro para (des)codificacao nao existente.\n", argv[2]);
        printf("Especifique um ficheiro ja criado.\n");
        return 0;
    }
    /*Conversão do parâmetro chave de formato string para inteiro */
    delta = atoi(argv[3]);
    if(strcmp(argv[1],"-c") == 0){
        printf("A encriptar o ficheiro usado uma chave fornecida\n");
        while((c = fgetc(file1)) != EOF){ //Ciclo para armazenar todo o conteúdo do ficheiro numa string.
            buffer[k] = c;
            k++;
        }
        k = 0;
        fclose(file1);
        file1 = fopen(argv[2], "w");
        while(buffer[k] != ''){//Ciclo para inserir a string anterior no ficheiro
            buffer[k] = (int)buffer[k] + delta; //Encriptacao do caracter
            fputc(buffer[k], file1);
            k++;
        }
        fclose(file1);
        printf("Sucesso!\n");
    }
    /* O mesmo acontece no processo de desencriptação excepto
       a formula de encriptação que e invertida */
    else if(strcmp(argv[1],"-d") == 0){
        printf("A desencriptar o ficheiro usado uma chave fornecida\n");
        while((c = fgetc(file1)) != EOF){
            buffer[k] = c;
            k++;
        }
        k = 0;
        fclose(file1);
        file1 = fopen(argv[2], "w");
        while(buffer[k] != ''){
            buffer[k] = (int)buffer[k] - delta;
            fputc(buffer[k], file1);
            k++;
        }
        fclose(file1);
        printf("Sucesso!\n");
    }
        else
            printf("Parametros incorrectos. Usar -help para a ajuda\n");
    return 0;
}

Hoje migrei do Blogspot para o WordPress. Os motivos vieram com a necessidade de implementar codigo no blog e o WordPress parece mais “profissional”.

Após um desafio do professor de programação a criar uma entrada no blog sobre como passar argumentos pela linha de comandos resolvi por mãos a obra. Visto que o objectivo do trabalho é fazer os colegas perceberem o que são os tais argumentos sem nunca ter ouvido falar deles, o texto está o mais simples possível.

Os argumentos servem para passar informação ao programa sem ter acesso ao código fonte.
A função principal de um programa, também conhecida como main(), assim como outras funções pode receber argumentos. Para passar os argumentos da função main basta chamar o programa na linha de comandos seguido de um ou mais argumentos separados por caracteres de espaço.

Exemplo:
./nome Manuel

Este programa iria agora conter uma string com o nome “Manuel” que podia ser usada como qualquer outra string. Todos os argumentos sao armazenados num vector conhecido como argv[].

Passando ao código, permitir ao programa receber estes argumentos e tão simples como declarar a função main da seguinte forma:

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

int argc: esta variável e apenas um numero inteiro que nos mostra quantos argumentos o programa recebe. O predefinido é 1, que é o nome do programa em uso. A partir dai cada argumento que o programa receber incrementa o argc.

char *argv[]: É um vector onde sao armazenados os argumentos em forma de string. A posição 0 (argv[0]) equivale ao nome do ficheiro. Os argumentos que o programa recebe serão a posição 1, 2 e assim sucessivamente. No caso do exemplo dado o argv[1] iria conter a string “Manuel”.

Exemplo do uso de argumentos em linguagem C.

Este pequeno programa verifica se há o argumento de nome (argv[0]) e mais um; caso contrário apenas mostra qual a sintaxe. Caso o programa receba com sucesso um argumento ele mostra-o ao utilizador.

#include 

int main(int argc, char *argv[]){
  if(argc != 2)
      printf("Syntax: args <name>\n");
  else
      printf("Argumento: %s\n" ,argv[1]);
  return 0;
}

O trabalho final do Módulo de Estruturas foi a realização de uma agenda, que teria várias funções como, por exemplo, inserir dados na agenda, eliminá-los, mostrar, procurar contactos, listá-los, etc.

Na generalidade, este trabalho correu bem, todos conseguiram terminar a tarefa, e, no meu caso, sem grande dificuldade.

Este trabalho foi um bom exemplo para treinar programas de maior dimensão. Contudo, sem uma validação exigente, nem uma interface gráfica, por isso, ainda é um trabalho amador, mas está no bom caminho…

Recentemente, foi-nos proposto criar o jogo do galo na linguagem c++, o professor da disciplina forneceu duas funções, uma para enviar 1 carácter para um determinado IP, e outra para receber 1 carácter do mesmo IP.

Na determinação de realizar este trabalho, o professor liberou algumas aulas para este fim. Mas o avanço ainda não foi significativo pois ninguém atingiu o fim deste programa.

No meu caso particular, o programa parecia estar perto da solução, mas depois falhou numa situação em que parecia resolvido. Sendo assim a solução será recomeçar com uma nova forma de abordar este algoritmo. Quando houver avanços, irei partilhar no meu blog.

Os apontadores são um tipo diferente de variável, cujo conteúdo não é mais do que um endereço de memória, endereço este que corresponde ao endereço de uma variável ou até de outro apontador na memória. Sendo que todas as variáveis estão alocadas na memória, os apontadores têm uma grande utilidade ao chamar uma variável.

No final do post está um exemplo de manipulação de apontadores.

Por exemplo, ao declarar:

int a;

…declaramos um inteiro, que é alocado na memória com um endereço próprio, com o nome de a.

Enquanto que:

int *apontador;

…é um apontador que ainda não aponta para nenhum endereço.

*apontador=&(endereço de memoria de)a;
…irá pôr o apontador *apontador a apontar para a.

Com isto, se quisermos modificar valores de uma variável dentro de uma função iremos modificar directamente a variável original em vez da sua cópia que as funções criam sempre. Na sua essência, um apontador poupa recursos de memória e facilita o acesso as variáveis.

Exemplo:

#include <stdio.h>

int main(int argc, char *argv[]){
	if(argc != 2)
		printf("Syntax: args <string>\n");
	else
		printf("Argumento: %s\n" ,argv[1]);
	return 0;
}