Programação 08/09

TRATAMENTO DE IMAGEM - PRIMEIRA EDIÇÃO

2009-10-12T04:31:00.000-07:00

Well de entre as centenas de edições que o professor nos mandou fazer esta foi a unica que me deu "gosto" fazer. consistia em editarmos um cavalo ao nosso gosto da seguinte imagem inicial:

BOTÃO DIREITO DO RATO; VER IMAGEM PARA VER A IMAGEM COMPLETA

O resultado final foi o seguinte:

The rastafari horse :)

Ano 09/10 -Tratamento de imagens

2009-09-30T03:01:00.000-07:00

Começamos este ano a fazer tratamento de imagens e com muita pena minha com o Gimp programa que não gosto. É verdade que é free mas não é comparavel ao seu "rival". o PS não só é profissional como mais fácil de usar e faz-se coisas muito melhores. O gimp tem as suas vantagens mas nenhuma que me agrade. O curso de Artes gráficas desta mesma escola dispõe das licenças de ps e não custava nada termos também. Mas pronto vai-se trabalhando e veremos noo que dá :)

Introdução aos Sistemas de Informação - BASE DE DADOS EM QT

2009-05-25T01:00:00.000-07:00

No modulo 12 uma nova componente foi introduzida, aprendemos a criar bases de dados em QT.
Antes da programação em si, começamos por criar uma pequena apresentação onde é explicado o básico sobre bases de dados, mySql, etc. que pode ser baixado no link seguinte:
http://www.4shared.com/file/107613229/b7dbe1d6/psisql.html

Agora a programação: No programa que eu fiz criei uma ligação a base de dados situada no phpmyadmin em qt mas antes de explicar umas imagens sobre o programa:

Nas imagens pode-se ver um semáforo, este semáforo fica vermelho quando não foi possível a ligação a base de dados e verde quando e possível, é no código que podemos por a nossa palavra passe, nome, etc, como se pode ver no seguinte extracto de código:

 myHostName="xxx.xxx.x.xxx";

    myDatabase="graca";

    myUserName="graca";

    myPassword="xxxxxxxxxx";



bool projectMovie::ligar_bd(){

if((db_status = createConnection(myHostName, myDatabase, myUserName, myPassword))){

createDatabase();

ui->label_2->setPixmap(QPixmap(":/images/green"));

setMenuStatus02();



    }else{

        ui->label_2->setPixmap(QPixmap(":/images/red"));

        setMenuStatusFAIL();

    }

    return db_status;



}

Depois criamos a tabela para isso temos que fazer um QtableView e digitar os dados como se pode ver no seguinte:

void projectMovie::createDatabase(){

    QSqlQuery query;

    query.exec("drop table movies");

    query.exec("create table movies ("

        "name varchar(20) primary key, "

        "rate varchar(20), "

        "idade_permitida varchar(20), "

        "bilhete varchar(20), "

        "sala int, "

        "disponibilidade varchar(20))"

    );

}







void projectMovie::createTestData(){

    QSqlQuery query;

    query.exec("insert into movies values('fast & furious', '*****', '+16', '5e', 5 ,'100%')");

    query.exec("insert into movies values('Mr Bean', '****', '+6', '5e', 3, '20%')");

    query.exec("insert into movies values('B13 2', '*****', '+18', '10e(vip room)', 10 ,'10%')");

    query.exec("insert into movies values('Tiago Costa', '*****', '+18', '10e', 1 ,'0%')");



}

por fim existem vários botões, cada um e um dialog onde podemos ver a tabela, inserir dados, eliminar dados e procurar.
No QT o resultado final é este:

MODULO 11 - QT COMES BACK

2009-01-21T08:13:00.000-08:00

No fim do módulo 10 e agora no começo deste módulo começamos a programar outra vez em QT;
Para isso duas novas ferramentas foram-nos apresentadas:
o QT Creator e o QT Designer (QT Creator Review)
Com este programa foi muito mais facil programar nesta plataforma... mas agora ao que interessa.
Fizemos vários tipos de programas como Dialogs:
Um “dialog” é construído utilizando um conjunto de widgets onde estabelecemos ligações (SIGNALS/SLOTS) entre eles. Para criar estes Dialogs precisamos de saber o básico de Herança (Explicado no post anterior) e de classes. Depois desta introduçao vamos começar o programa. O que eu fiz foi um widget que nos mostra as matrículas portuguesas:
O resultado final será este:

Agora o programa:
IdAutomovelDialog.cpp

#include <QtGui>

#include "IdDoAutomovelDialog.h"

IdDoAutomovelDialog::IdDoAutomovelDialog(QWidget *parent):QDialog(parent){
    //Label
    label = new QLabel("&Matrícula:");

    //Line Edit
    lineEdit = new QLineEdit;

    //Buddyes
    label->setBuddy(lineEdit);

    //Spacer
    horizontalSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);

    //OK Button
    okButton = new QPushButton("Ok");
    okButton->setEnabled(false);

    //CANCEL Button
    cancelButton = new QPushButton("Cancel");
    cancelButton->setObjectName(QString::fromUtf8("cancelButton"));

    //Validar a matrícula introduzida ( http://pt.wikipedia.org/wiki/Matr%C3%ADculas_autom%C3%B3veis_em_Portugal )
    listaMatriculasValidas = new QStringList;
    listaMatriculasValidas->append("[A-Za-z]{2,2}[-][0-9]{2,2}[-][0-9]{2,2}");
    listaMatriculasValidas->append("[0-9]{2,2}[-][0-9]{2,2}[-][A-Za-z]{2,2}");      //or
    listaMatriculasValidas->operator <<("[0-9]{2,2}[-][A-Za-z]{2,2}[-][0-9]{2,2}");
    QRegExp regExp(listaMatriculasValidas->join("|"));
    lineEdit->setValidator(new QRegExpValidator(regExp, this));

    //Definir acções
    connect(lineEdit, SIGNAL(textChanged(const QString &)),
            this, SLOT(on_lineEdit_textChanged()));

    connect(okButton, SIGNAL(clicked()),
            this, SLOT(accept()));
    connect(cancelButton, SIGNAL(clicked()),
            this, SLOT(close()));

    //layout Dialog
    horizontalLayout = new QHBoxLayout;
    horizontalLayout_2 = new QHBoxLayout;
    verticalLayout = new QVBoxLayout;

    horizontalLayout->addWidget(label);
    horizontalLayout->addWidget(lineEdit);

    horizontalLayout_2->addItem(horizontalSpacer);
    horizontalLayout_2->addWidget(okButton);
    horizontalLayout_2->addWidget(cancelButton);

    verticalLayout->addLayout(horizontalLayout);
    verticalLayout->addLayout(horizontalLayout_2);

    setWindowTitle("Matrícula");
    setLayout(verticalLayout);

    //Tab order
    QWidget::setTabOrder(lineEdit, okButton);
    QWidget::setTabOrder(okButton, cancelButton);
}

void IdDoAutomovelDialog::on_lineEdit_textChanged(){
    okButton->setEnabled(lineEdit->hasAcceptableInput());
}

IdAutomovelDialog.h

#ifndef IDDOAUTOMOVELDIALOG_H
#define IDDOAUTOMOVELDIALOG_H

#include <QDialog>

class QLabel;
class QLineEdit;
class QSpacerItem;
class QPushButton;
class QHBoxLayout;
class QVBoxLayout;
class QString;
class QRegExp;

class IdDoAutomovelDialog : public QDialog
{
    Q_OBJECT

public:
    IdDoAutomovelDialog(QWidget *parent = 0);

private slots:
    void on_lineEdit_textChanged();

private:
    QLabel *label;
    QLineEdit *lineEdit;
    QSpacerItem *horizontalSpacer;
    QPushButton *okButton;
    QPushButton *cancelButton;
    QStringList *listaMatriculasValidas;
    QVBoxLayout *verticalLayout;
    QHBoxLayout *horizontalLayout;
    QHBoxLayout *horizontalLayout_2;
};

#endif // IDDOAUTOMOVELDIALOG_H

main.cpp

#include <QApplication>

#include "IdDoAutomovelDialog.h"

int main(int argc, char *argv[]){
    QApplication app(argc, argv);
    IdDoAutomovelDialog *dialog = new IdDoAutomovelDialog;
    dialog->show();
    return app.exec();
}

Isto feito neste programa foi mesmo o mais facil; O mais dificil vem a seguir; Inda em QT mas agora falando de streaming;
Streaming é basicamente troca de dados através de 2 novas funçoes de QT:
-QTextStream: para manipular dados no formato de texto.
-QDataStream: Para manipular dados no formato binário.

O primeiro a ser falado foi o QTextStream talvez por ser o mais facil; Isto permite trocar dados em apenas formato de texto.
Aqui um pequeno programa de exemplo:
dialog.h

#define DIALOG_H

#include <QtGui/QDialog>
#include <QMessageBox>
#include <QTextStream>
#include <QFile>

namespace Ui
{
    class DialogClass;
}

class Dialog : public QDialog
{
    Q_OBJECT

public:
    Dialog(QWidget *parent = 0);
    ~Dialog();
private slots:
    void processar();
private:
    Ui::DialogClass *ui;
    QFile original;
    QFile copia;
    QString line, new_line;
};

#endif // DIALOG_H

dialog.cpp

#include "dialog.h"
#include "ui_dialog.h"

Dialog::Dialog(QWidget *parent)
    : QDialog(parent), ui(new Ui::DialogClass)
{
    ui->setupUi(this);
    connect(ui->cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
    connect(ui->okButton, SIGNAL(clicked()), this, SLOT(accept()));
    connect(ui->goButton, SIGNAL(clicked()), this, SLOT(processar()));
}

Dialog::~Dialog()
{
    delete ui;
}

void Dialog::processar(){
    QMessageBox msgBox;
    msgBox.setModal(true);
    if(ui->original->text().isEmpty() || ui->copia->text().isEmpty() ||
       ui->palavra->text().isEmpty() || ui->novapalavra->text().isEmpty()){
        msgBox.setText("É obrigatório o preenchimento de todos os campos!");
        msgBox.exec();
    }else{
        original.setFileName(ui->original->text());
        copia.setFileName(ui->copia->text());
        if (original.open(QFile::ReadOnly)) {
            copia.open(QFile::WriteOnly);
            QTextStream in(&original);
            QTextStream out(&copia);
            out.setCodec("UTF-8");
            in.setCodec("UTF-8");
            do {
                line = in.readLine();
                new_line = line;
                new_line.replace(ui->palavra->text(), ui->novapalavra->text());
                out << new_line << endl;
            } while (!line.isNull());
            original.close();
            copia.close();
            msgBox.setText("Sucesso!");
            msgBox.exec();;

        }else{
            msgBox.setText("Erro ao abrir o ficheiro: " + ui->original->text());
            msgBox.exec();;
        }
    }
}

Como o modo grafico deste programa é gerado pelo QTDesigner eu ponho aqui um link para download do projecto completo que contém além disto um .ui e um main.cpp.
Link para Download

Agora ainda mais difícil começamos a falar do QDataStream:
QDataStream permite a troca de datagramas como neste programa:

Este programa contém dois ficheiros um que recebe e um que envia dados no caso um receiver e um sender;

Agora o código; Como no exemplo anterior este código também é gerado pelo QTDesigner e Contém ainda um resource file com imagens do programa;
Deixo o link com o programa completo cujo download pode ser feito clicando aqui

RECEIVER
receiver.cpp

#include "receiver.h"
#include "ui_receiver.h"

receiver::receiver(QWidget *parent)
    : QWidget(parent), ui(new Ui::receiverClass)
{
    ui->setupUi(this);
    udpSocket = new QUdpSocket(this);
    udpSocket->bind(45454);
    connect(udpSocket, SIGNAL(readyRead()),
             this, SLOT(datagramreceiver()));




}

receiver::~receiver()
{
    delete ui;
}
void receiver::datagramreceiver(){





    QByteArray datagram;

    do {
        datagram.resize(udpSocket->pendingDatagramSize());
        udpSocket->readDatagram(datagram.data(), datagram.size());
    } while (udpSocket->hasPendingDatagrams());

    int m;
    bool n;

    QDataStream in(&datagram, QIODevice::ReadOnly);
    in.setVersion(QDataStream::Qt_4_1);
    in >> m >> n;    //for more data in >> m >> n >> o >> p >> ...;

      if(m == ui->lineEdit->text().toInt()){
          if(n)
            ui->pushButton->setIcon(QIcon(":/imagens/open"));
          else
          ui->pushButton->setIcon(QIcon(":/imagens/close"));


    }
}

receiver.h

#ifndef RECEIVER_H
#define RECEIVER_H

#include <QtGui/QWidget>
#include <QUdpSocket>
#include <QDataStream>
#include <QRegExp>


namespace Ui
{
    class receiverClass;

}

class receiver : public QWidget
{
    Q_OBJECT

public:
    receiver(QWidget *parent = 0);
    ~receiver();

private slots:
    void datagramreceiver();

private:
    Ui::receiverClass *ui;
    QUdpSocket *udpSocket;
};

#endif // RECEIVER_H

SENDER
sender.cpp

#include "sender.h"
#include "ui_sender.h"

sender::sender(QWidget *parent)
    : QWidget(parent), ui(new Ui::senderClass)
{
    ui->setupUi(this);
    cancela[0] = ui->push1;
    cancela[1] = ui->push2;
    cancela[2] = ui->push3;
    cancela[3] = ui->push4;
    cancela[4] = ui->push5;
    cancela[5] = ui->push6;
    cancela[6] = ui->push7;
    cancela[7] = ui->push8;
    cancela[8] = ui->push9;
    cancela[9] = ui->push10;

    QSignalMapper *signalMapper = new QSignalMapper(this);
    connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(mudacancela(int)));

    for(int i = 0; i < 10; i++){


        signalMapper->setMapping(cancela[i], i);
        connect(cancela[i], SIGNAL(clicked()), signalMapper, SLOT(map()));
        estado[i]=true;
    }
  udpSocket = new QUdpSocket(this);


}
sender::~sender()
{
    delete ui;
}

void sender::mudacancela(int m){
    //bool n=false;
    estado[m] = !estado[m];
    if(estado[m])
        cancela[m]->setIcon(QIcon(":/imagens/open"));
    else
        cancela[m]->setIcon(QIcon(":/imagens/close"));
    QByteArray datagram;
    QDataStream out(&datagram, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_4_1);
    out << m << estado[m];   //for more data out << m << n << o << p << ...;
    udpSocket->writeDatagram(datagram, QHostAddress::LocalHost, 45454);
}

sender.h

#ifndef SENDER_H
#define SENDER_H

#include <QtGui/QWidget>
#include <QSignalMapper>
#include <QUdpSocket>
#include <QPushButton>

namespace Ui
{
    class senderClass;
}

class sender : public QWidget
{
    Q_OBJECT

public:
    sender(QWidget *parent = 0);
    ~sender();
private slots:
    void mudacancela(int m);
private:
    Ui::senderClass *ui;
    QPushButton *cancela[10];
    QUdpSocket *udpSocket;
    bool estado[10];
};

#endif // SENDER_H

Para vermos isto a funcionar é só abrir os dois programas e trabalhar no sender; Ao carregar numa cancela para abri-la por exemplo no receiver a cancela abre também.

MODULO 10 - classes derivadas - Herança

2009-01-14T07:46:00.000-08:00

Neste começo de modulo começamos por falar de classes de derivadas, e dentro disso falamos de Herança
A herança é basicamente uma relação entre duas classes, sendo uma criada a partir de outra já existente.
A classe já existente designa-se de classe-base; A nova classe designa-se de classe-derivada.
Vou agora dar um pequeno exemplo:
Classe-base
Poligono.h

#ifndef POLIGONO_H
#define POLIGONO_H
#include <string>
using namespace std;
class Poligono{
    //Definição Matemática
    /*
     Figura plana limitada por segmentos de recta, chamados lados dos polígonos
     onde cada segmento de recta, intersecta exactamente dois outros extremos.
     Exemplos de polígonos: http://pt.wikipedia.org/wiki/Polígono
     */
public:
    Poligono();
    void setNome(string novo_nome);
    string getNome();
private:
    string nome;
};
#endif    //POLIGONO_H

Poligono.cpp

#include "Poligono.h"

Poligono::Poligono(){nome="Não definido!";}

void Poligono::setNome(string novo_nome){nome = novo_nome;}

string Poligono::getNome(){return nome;}

main.cpp

#include <iostream>
#include "Poligono.h"
using namespace std;
int main(){
    Poligono figura1;
    figura1.setNome("Quadrilátero");
    cout << figura1.getNome() << endl;
}

No programa
- É composto por 3 ficheiros
- o primeiro é onde a classe é criada.
- No segundo define-se o nome.
- No main ele chama as funçoes criadas em Poligono.cpp neste caso o nome (getNome)
Para compilar:

g++ -Wall main.cpp Poligono.cpp -o p
./p

Classe-derivada

Nota:A esta versão serão juntos os ficheiros criados atrás Poligono.cpp e Poligono.h

Triangulo.h

#ifndef TRIANGULO_H
#define TRIANGULO_H
#include "Poligono.h"
class Triangulo : public Poligono {
    
public:
    Triangulo();
    void setLados(float new_lado, float new_altura);
    float getLado();
    float getAltura();
    float area();    
    float Perimetro();
private:
    float lado;
    float altura;    
};
#endif

Triangulo.cpp

#include "Triangulo.h"

Triangulo::Triangulo(){
    lado = 3;
    altura = 3;
    
}

void Triangulo::setLados(float new_lado, float new_altura){
    lado = new_lado;
    altura= new_altura;
    
}

float Triangulo::getLado(){return lado;}

float Triangulo::getAltura(){return altura;}

float Triangulo::area(){return lado*altura/2;}

float Triangulo::Perimetro(){return lado+lado+lado;}

Rectangulo.h

#ifndef RECTANGULO_H
#define RECTANGULO_H
#include "Poligono.h"
class Rectangulo : public Poligono {
    
public:
    Rectangulo();
    void setLados(float new_lado1, float new_lado2, float new_comprimento, float new_largura);
    float getLado1();
    float getLado2();
    float getComprimento();
    float getLargura();
    float area();    
    float Perimetro();
private:
    float lado1;
    float lado2;
    float comprimento;
    float largura;    
};
#endif

Rectangulo.cpp

#include "Rectangulo.h"

Rectangulo::Rectangulo(){
    lado1 = 3;
    lado2 = 3;
    comprimento = 3;
    largura = 3;
    
}

void Rectangulo::setLados(float new_lado1, float new_lado2, float new_comprimento, float new_largura){
    lado1 = new_lado1;
    lado2 = new_lado2;
    comprimento = new_comprimento;
    largura = new_largura;
}

float Rectangulo::getLado1(){return lado1;}

float Rectangulo::getLado2(){return lado2;}

float Rectangulo::getComprimento(){return comprimento;}

float Rectangulo::getLargura(){return largura;}

float Rectangulo::area(){return comprimento*largura;}

float Rectangulo::Perimetro(){return lado1 + lado2 + comprimento + largura;}

Quadrado.h

#ifndef QUADRADO_H
#define QUADRADO_H
#include "Poligono.h"
class Quadrado : public Poligono {
    
public:
    Quadrado();
    void setLados(float new_lado);
    float getLado();
    float area();    
    float Perimetro();
private:
    float lado;
        
};
#endif

Quadrado.cpp

#include "Quadrado.h"

Quadrado::Quadrado(){
    lado = 3;
    
    
}

void Quadrado::setLados(float new_lado){
    lado = new_lado;
    
}

float Quadrado::getLado(){return lado;}



float Quadrado::area(){return lado*lado;}

float Quadrado::Perimetro(){return lado + lado + lado + lado;}

Depois de isto criado iremos agora pôr o menu. Este Menu será substituido pelo main:
menu.cpp

#include <iostream>
#include "Triangulo.h"
#include "Quadrado.h"
#include "Rectangulo.h"
#include <stdlib.h>

using namespace std;
int main(void){
    Triangulo figura1; 
    Quadrado figura2;
    Rectangulo figura3;
    
    char opcao;
    cout<<"Escolha uma de 3 opçoes: (t)=Triangulo, (x)=Quadrado, (r)=Rectangulo"<<endl;
    cin>>opcao;

    do{
        
            if(opcao == 't'){
            figura1.setNome("Triângulo");
            figura1.setLados(10,9);
            cout << "Nome : " << figura1.getNome() << endl;
            cout << "Comprimento de cada 1 dos 3 lados : " << figura1.getLado() << endl;
            cout << "altura: " <<figura1.getAltura() << endl;
            cout << "Soma dos comprimentos dos lados: " << figura1.Perimetro() << endl;
            cout << "a area e: "<<figura1.area() <<endl;
            cout<<"(q) para sair"<<endl;
            cin>>opcao;
        }
        
        if(opcao == 'x'){
            figura2.setNome("Quadrado");
            figura2.setLados(4);
            cout << "Nome : " << figura2.getNome() << endl;
            cout << "Comprimento dos lados : " << figura2.getLado() << endl;
            cout << "Soma dos comprimentos dos lados: " << figura2.Perimetro() << endl;
            cout << "a area e: "<<figura2.area() <<endl;
            cout<<"(q) para sair"<<endl;
            cin>>opcao;
    }
    
        if(opcao == 'r'){
            figura3.setNome("Rectangulo");
            figura3.setLados(6,3,6,3);
            cout << "Nome : " << figura3.getNome() << endl;
            cout << "Comprimento do lado 1: " << figura3.getLado1() << endl;
            cout << "Largura do lado 2: " << figura3.getLado2() << endl;
            cout << "Comprimento da lado 3: " << figura3.getComprimento() << endl;
            cout << "Largura do lado 4: " << figura3.getLargura() << endl;
            cout << "Soma dos comprimentos dos lados: " << figura3.Perimetro() << endl;
            cout << "a area e: "<< figura3.area() <<endl;
            cout<<"(q) para sair"<<endl;
            cin>>opcao;
    }
    
    }while(opcao != 'q');
    return 0;
}

Para compilar:

g++ -Wall menu.cpp Poligono.cpp Quadrado.cpp Triangulo.cpp Rectangulo.cpp -o p
./p

No programa
- Sao criados 7 novos programas e substituidos 1 (main.cpp por menu.cpp)
- Nos programas criados sao feitas novas classes-derivadas do Poligono entre elas Triangulo.h/Triangulo.cpp
- Sao mostrados nos programas os lados e criadas areas e perimetros
- Depois no menu é criado um char opcao; essa opcao serve para mostrar na consola uma escolha a ser feita pelo utilizador (r)/(x)/(t) e um para fechar(q).

Para finalizar criamos um diagrama de classes deste programa feito no Umbrello UML Modeller:

MODULO 9 - PARADIGMA ADT

2008-12-16T01:39:00.000-08:00

Vou começar por dizer o que é ADT:
Tipo Abstracto de Dados (A.D.T.) é um conjunto de operações sobre uma
colecção de dados armazenados.
Por exemplo, no caso de uma lista ligada podemos sempre definir as operações de
inserção, remoção, comprimento, etc. sem que para isso tenhamos que definir qual a
estrutura de dados escolhida para a sua representação.
Bem será mais facilde explicar com um pequeno exemplo feito por mim na aula.

Neste programa, estou a criar uma casa muito simples com um comando á distancia onde ao clicar abre ou a porta ou a janela;
primeiro vou mostra-lo todo junto sem separar as funçoes:

#include <iostream>
#include <string>
using namespace std;
class Casa{
public:
    Casa(){
        Porta=false;
        Luz=false;
    }
    void CarregouBotaoPorta();
    void CarregouBotaoLuz();
    void EstadoDaLuz();
    void EstadoDaPorta();
    void MostrarLuz();
    void MostrarPorta();

private:
    bool Porta;
    bool Luz; 
};

void Casa::CarregouBotaoPorta(){
    if(Porta == true)
        Porta = false;
    else
        Porta = true;
}
void Casa::CarregouBotaoLuz(){
    if(Luz == true)
        Luz = false;
    else
        Luz = true;
}
void Casa::EstadoDaLuz(){
    if(Luz == true)
        cout<<"a luz esta ligada"<<endl;
    else 
        cout<<"a luz esta desligada"<<endl;
}
void Casa::EstadoDaPorta(){
    if(Porta == true)
        cout<<"a porta esta aberta"<<endl;
    else 
        cout<<"a porta esta fechada"<<endl;
}
void Casa::MostrarPorta(){
    if(Porta == false){
        cout<<"porta fechada"<<endl;
        cout<<" ______________________"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |    +------------+    |"<<endl;
        cout<<" |    |            |    |"<<endl;         
        cout<<" |    |            |    |"<<endl;          
        cout<<" |    |            |    |"<<endl;         
        cout<<" |    |            |    |"<<endl;
        cout<<" |    |          o |    |"<<endl;        
        cout<<" |    |            |    |"<<endl;        
        cout<<" |    |            |    |"<<endl;                
        cout<<" |    |            |    |"<<endl;             
        cout<<" |    |            |    |"<<endl;            
        cout<<" |    |            |    |"<<endl;            
        cout<<" |    +------------+    |"<<endl;           
        cout<<" ------------------------"<<endl;
    }
    else{ 
        cout<<"porta aberta"<<endl;
        cout<<" ______________________"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |    +------------+    |"<<endl;
        cout<<" |    |////////////|    |"<<endl;         
        cout<<" |    |////////////|    |"<<endl;          
        cout<<" |    |////////////|    |"<<endl;         
        cout<<" |    |////////////|    |"<<endl;
        cout<<" |    |////////////|    |"<<endl;        
        cout<<" |    |////////////|    |"<<endl;        
        cout<<" |    |////////////|    |"<<endl;                
        cout<<" |    |////////////|    |"<<endl;             
        cout<<" |    |////////////|    |"<<endl;            
        cout<<" |    |////////////|    |"<<endl;            
        cout<<" |    +------------+    |"<<endl;           
        cout<<" ------------------------"<<endl;
    }
}
void Casa::MostrarLuz(){
    if(Luz==false){
    cout<<"a luz esta fechada"<<endl;    
   cout<<" _______"<<endl;
   cout<<"+       +"<<endl;
  cout<<"+         +"<<endl;
 cout<<"+           +"<<endl;
 cout<<"+           +"<<endl;
  cout<<"+    _     +"<<endl;
   cout<<"+  | |   +"<<endl;
    cout<<"+ | | +"<<endl; 
     cout<<"+| |+"<<endl;
     cout<<"/////"<<endl;
     cout<<"/////"<<endl;
     cout<<"/////"<<endl;
    }
    else{
    cout<<"a luz esta acesa"<<endl;    
   cout<<" _______"<<endl;
   cout<<"+ + + + +"<<endl;
  cout<<"+  + + +  +"<<endl;
 cout<<"+ + + + + + +"<<endl;
 cout<<"+ + + + + + +"<<endl;
  cout<<"++ + _ +  +"<<endl;
   cout<<"+ +|+|+ +"<<endl;
    cout<<"++|+|++"<<endl; 
     cout<<"+|+|+"<<endl;
     cout<<"/////"<<endl;
     cout<<"/////"<<endl;
     cout<<"/////"<<endl;
    }
}


int main(){
    Casa tiago, porta, luz;
    tiago.EstadoDaLuz();
    tiago.EstadoDaPorta();
    
    tiago.MostrarLuz();
    tiago.MostrarPorta();
    
    
    
    return 0;
}

Em primeiro começo por dizer que este programa é gravado como nome.cpp por exemplo.

agora um pequeno desenho basico do que faz este programa

Agora o que ele faz; Ele cria uma casa com uma porta, uma luz e um comando; a partir desse comando podemos abrir a luz, fechar a luz, abrir a porta ou fechar a porta.
Em ADT os programas podem ser separados em 3 passos mas isso vou explicar mais a frente.

Agora vou explicar alguns passos aqui feitos:
-Criar uma funçao public e private; Na public criamos as funçoes void criados no programa á frente como esta:

void Casa::CarregouBotaoPorta(){
    if(Porta == true)
        Porta = false;
    else
        Porta = true;
}

-Na private criamos 2 bools um para a porta outra outro para a luz. Estas variaveis por estarem no private estao protegidas.

- A seguir criamos as funçoes void. as 2 primeiras para carregar na porta e na luz e criamos um if e um else que diz que caso a porta seja true significa que está aberta; false significa que está fechada e para a luz igual.

- Depois criamos um estado da luz e da porta.

- Por fim um mostrar luz e porta com um pequeno desenho em couts

-Depois para acabar é aberto um int main onde o programa mostra na consola o que fizemos nas funçoes void.

Depois deste programa todo junto vamos agora separa-lo em 3 ficheiros;

o primeiro é o Casa.h:

#ifndef CASA_H
#define CASA_H
#include <string>
using namespace std;
class Casa{
public:
    Casa(){
        Porta=false;
        Luz=false;
    }
    void CarregouBotaoPorta();
    void CarregouBotaoLuz();
    void EstadoDaLuz();
    void EstadoDaPorta();
    void MostrarLuz();
    void MostrarPorta();

private:
    bool Porta;
    bool Luz; 
};
#endif

Agora um casa.cpp:

#include <iostream>
#include "Casa.h"
using namespace std;
void Casa::CarregouBotaoPorta(){
    if(Porta == true)
        Porta = false;
    else
        Porta = true;
}
void Casa::CarregouBotaoLuz(){
    if(Luz == true)
        Luz = false;
    else
        Luz = true;
}
void Casa::EstadoDaLuz(){
    if(Luz == true)
        cout<<"a luz esta ligada"<<endl;
    else 
        cout<<"a luz esta desligada"<<endl;
}
void Casa::EstadoDaPorta(){
    if(Porta == true)
        cout<<"a porta esta aberta"<<endl;
    else 
        cout<<"a porta esta fechada"<<endl;
}
void Casa::MostrarPorta(){
    if(Porta == false){
        cout<<"porta fechada"<<endl;
        cout<<" ______________________"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |    +------------+    |"<<endl;
        cout<<" |    |            |    |"<<endl;         
        cout<<" |    |            |    |"<<endl;          
        cout<<" |    |            |    |"<<endl;         
        cout<<" |    |            |    |"<<endl;
        cout<<" |    |          o |    |"<<endl;        
        cout<<" |    |            |    |"<<endl;        
        cout<<" |    |            |    |"<<endl;                
        cout<<" |    |            |    |"<<endl;             
        cout<<" |    |            |    |"<<endl;            
        cout<<" |    |            |    |"<<endl;            
        cout<<" |    +------------+    |"<<endl;           
        cout<<" ------------------------"<<endl;
    }
    else{ 
        cout<<"porta aberta"<<endl;
        cout<<" ______________________"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |                      |"<<endl;
        cout<<" |    +------------+    |"<<endl;
        cout<<" |    |////////////|    |"<<endl;         
        cout<<" |    |////////////|    |"<<endl;          
        cout<<" |    |////////////|    |"<<endl;         
        cout<<" |    |////////////|    |"<<endl;
        cout<<" |    |////////////|    |"<<endl;        
        cout<<" |    |////////////|    |"<<endl;        
        cout<<" |    |////////////|    |"<<endl;                
        cout<<" |    |////////////|    |"<<endl;             
        cout<<" |    |////////////|    |"<<endl;            
        cout<<" |    |////////////|    |"<<endl;            
        cout<<" |    +------------+    |"<<endl;           
        cout<<" ------------------------"<<endl;
    }
}
void Casa::MostrarLuz(){
    if(Luz==false){
    cout<<"a luz esta fechada"<<endl;    
   cout<<" _______"<<endl;
   cout<<"+       +"<<endl;
  cout<<"+         +"<<endl;
 cout<<"+           +"<<endl;
 cout<<"+           +"<<endl;
  cout<<"+    _     +"<<endl;
   cout<<"+  | |   +"<<endl;
    cout<<"+ | | +"<<endl; 
     cout<<"+| |+"<<endl;
     cout<<"/////"<<endl;
     cout<<"/////"<<endl;
     cout<<"/////"<<endl;
    }
    else{
    cout<<"a luz esta acesa"<<endl;    
   cout<<" _______"<<endl;
   cout<<"+ + + + +"<<endl;
  cout<<"+  + + +  +"<<endl;
 cout<<"+ + + + + + +"<<endl;
 cout<<"+ + + + + + +"<<endl;
  cout<<"++ + _ +  +"<<endl;
   cout<<"+ +|+|+ +"<<endl;
    cout<<"++|+|++"<<endl; 
     cout<<"+|+|+"<<endl;
     cout<<"/////"<<endl;
     cout<<"/////"<<endl;
     cout<<"/////"<<endl;
    }
}

E por fim um main.cpp:

#include "Casa.h"
int main(){
    Casa tiago, porta, luz;
    tiago.EstadoDaLuz();
    tiago.EstadoDaPorta();
    
    tiago.MostrarLuz();
    tiago.MostrarPorta();
    
    
    
    return 0;
}

Para compilar nao e igual á forma normal;
Basta abrir a consola, entrar na pasta onde está o programa e digitar o seguinte:

g++ -Wall main.cpp Casa.cpp -o casa

INTRODUÇAO AO QT

2008-11-10T01:36:00.000-08:00

Começamos a pouco tempo o modulo 8 e a matéria introduzida foi QT.
Qt através da definição da wikipedia é um sistema multi-plataforma para o desenvolvimento de programas de interface gráfica.
Pode ser usado em 2 linguagens java ou c++ o que usamos foi o c++ pois ja tínhamos as bases logo é mais fácil.
a primeira coisa a saber é a forma como compilar o programa pois e completamente diferente de "C".
compilando:

1- criar pasta com nome á escolha que vai ser o nome do programa
2- abrir a consola;
3- digitar os comandos para localizar o ficheiro (ex.: cd/Desktop/pasta)
4- qmake -project
5 - qmake -pasta.pro (neste caso e pasta pois foi o nome dado)
6- make
depois e verificado se o programa tem erros se nao tiver:
7- ./pasta (neste caso e pasta porque foi o nome dado)

Agora que ja sabemos compilar vamos passar á pratica;
Este é um programa feito por mim mesmo na aula; á primeira vista pode parecer muito grande mas até é simples pois baseia-se em copy+paste.
Ele apenas diz os dias da semana e classifica-os de 1 a 5;

#include <QApplication>
#include <QLabel>
#include <QVBoxLayout>
#include <QSpacerItem>
#include <QSpinBox>
#include <QSlider>
#include <QPushButton>
int main(int argc, char *argv[]){
  QApplication app(argc, argv);
  QWidget *janela = new QWidget;
  
  
  
  QLabel *texto1 = new QLabel("SEGUNDA\n");
  QLabel *texto2 = new QLabel("TERCA\n");
  QLabel *texto3 = new QLabel("QUARTA\n");
  QLabel *texto4 = new QLabel("QUINTA\n");
  QLabel *texto5 = new QLabel("SEXTA\n");
  QLabel *texto6 = new QLabel("SABADO\n");
  QLabel *texto7 = new QLabel("DOMINGO\n");
  
  QSpinBox *spinbox1 = new QSpinBox; 
  QSpinBox *spinbox2 = new QSpinBox;
  QSpinBox *spinbox3 = new QSpinBox;
  QSpinBox *spinbox4 = new QSpinBox;
  QSpinBox *spinbox5 = new QSpinBox;
  QSpinBox *spinbox6 = new QSpinBox;
  QSpinBox *spinbox7 = new QSpinBox;
  spinbox1->setRange(1,5);
  spinbox2->setRange(1,5);
  spinbox3->setRange(1,5);
  spinbox4->setRange(1,5);
  spinbox5->setRange(1,5);
  spinbox6->setRange(1,5);
  spinbox7->setRange(1,5);
  QSpacerItem *spacer1 = new QSpacerItem(400,0);
  
  QSlider *sliderhorizontal1 = new QSlider(Qt::Horizontal);
  QSlider *sliderhorizontal2 = new QSlider(Qt::Horizontal);
  QSlider *sliderhorizontal3 = new QSlider(Qt::Horizontal);
  QSlider *sliderhorizontal4 = new QSlider(Qt::Horizontal);
  QSlider *sliderhorizontal5 = new QSlider(Qt::Horizontal);
  QSlider *sliderhorizontal6 = new QSlider(Qt::Horizontal);
  QSlider *sliderhorizontal7 = new QSlider(Qt::Horizontal);
  sliderhorizontal1->setRange(1,5);
  sliderhorizontal2->setRange(1,5);
  sliderhorizontal3->setRange(1,5);
  sliderhorizontal4->setRange(1,5);
  sliderhorizontal5->setRange(1,5);
  sliderhorizontal6->setRange(1,5);
  sliderhorizontal7->setRange(1,5);
        QPushButton *sair = new QPushButton("SAIR"); 
        QObject::connect ( sair, SIGNAL(clicked()), &app, SLOT(quit()));
        
      QObject::connect ( spinbox1, SIGNAL(valueChanged( int)), sliderhorizontal1, SLOT(setValue (int)));  
    QObject::connect ( sliderhorizontal1, SIGNAL(valueChanged( int)), spinbox1, SLOT(setValue (int)));  
    QObject::connect ( spinbox2, SIGNAL(valueChanged(int )), sliderhorizontal2, SLOT(setValue (int)));  
      QObject::connect ( sliderhorizontal2, SIGNAL(valueChanged(int)), spinbox2, SLOT(setValue (int)));  
      QObject::connect ( spinbox3, SIGNAL(valueChanged( int)), sliderhorizontal3, SLOT(setValue (int)));  
    QObject::connect ( sliderhorizontal3, SIGNAL(valueChanged( int)), spinbox3, SLOT(setValue (int)));  
    QObject::connect ( spinbox4, SIGNAL(valueChanged(int )), sliderhorizontal4, SLOT(setValue (int)));  
      QObject::connect ( sliderhorizontal4, SIGNAL(valueChanged(int)), spinbox4, SLOT(setValue (int)));  
      QObject::connect ( spinbox5, SIGNAL(valueChanged( int)), sliderhorizontal5, SLOT(setValue (int)));  
    QObject::connect ( sliderhorizontal5, SIGNAL(valueChanged( int)), spinbox5, SLOT(setValue (int)));  
    QObject::connect ( spinbox6, SIGNAL(valueChanged(int )), sliderhorizontal6, SLOT(setValue (int)));  
      QObject::connect ( sliderhorizontal6, SIGNAL(valueChanged(int)), spinbox6, SLOT(setValue (int)));    
    QObject::connect ( spinbox7, SIGNAL(valueChanged(int )), sliderhorizontal7, SLOT(setValue (int)));  
      QObject::connect ( sliderhorizontal7, SIGNAL(valueChanged(int)), spinbox7, SLOT(setValue (int)));    
  
  
  
        //criar layouts
  QVBoxLayout *coluna1 = new QVBoxLayout;
  QVBoxLayout *coluna2 = new QVBoxLayout;
  QVBoxLayout *coluna3 = new QVBoxLayout;
  QVBoxLayout *coluna4 = new QVBoxLayout;
  QHBoxLayout *corpo = new QHBoxLayout;
  QHBoxLayout *base1 = new QHBoxLayout;
  QHBoxLayout *base2 = new QHBoxLayout;
        QVBoxLayout *principal = new QVBoxLayout;
  
  coluna1->addWidget(texto1);
  coluna1->addWidget(texto2);
  coluna1->addWidget(texto3);
  coluna1->addWidget(texto4);  
  coluna1->addWidget(texto5);  
  coluna1->addWidget(texto6);
  coluna1->addWidget(texto7);  
  
  coluna2->addWidget(spinbox1);
  coluna2->addWidget(spinbox2);
  coluna2->addWidget(spinbox3);
  coluna2->addWidget(spinbox4);
  coluna2->addWidget(spinbox5);
  coluna2->addWidget(spinbox6);
  coluna2->addWidget(spinbox7);
  

  coluna3->addWidget(sliderhorizontal1);
  coluna3->addWidget(sliderhorizontal2);
  coluna3->addWidget(sliderhorizontal3);
  coluna3->addWidget(sliderhorizontal4);
  coluna3->addWidget(sliderhorizontal5);
  coluna3->addWidget(sliderhorizontal6);
  coluna3->addWidget(sliderhorizontal7);  

  corpo->addLayout(coluna1);
  corpo->addLayout(coluna2);
  corpo->addLayout(coluna3);
  corpo->addLayout(coluna4);
  
    base1->addItem(spacer1);
  base2->addWidget(sair);
    principal->addLayout(corpo);
  principal->addLayout(base1);
  principal->addLayout(base2);
  
  janela->setLayout(principal);
  janela->show();
  return app.exec();
}

Programa linha-a-linha:
1-7 -> nestas linhas são usados varios #include que servem para criar aplicaçoes, items ou wigets;
8-9 -> inicia aplicaçao a partir da consola;
14-20 -> começamos a fazer labels que sao basicamente texto; neste caso com os dias da semana.
22-35 -> da 22 á 28 sao criadas spinboxs que sao as caixas com numeros existentes no programa da 29 á 35 sao criadas ranges que fazem com que a spinbox apenas possa irdo numero 1 ao 5;
36 -> aqui e criado um spacer que faz com que a janela nao seja minimizada menos que 400 pixels neste caso;
38-51 -> da 38 á 44 sao criados sliders horizontais da 45 á 51 criamos outra vez ranges que fazem com que o slider apenas va de 1 a 5;
52-53 -> é criado um pushbutton com o nome sair; isto cria um botao no nosso que quando clicado o programa fecha.
55-68 -> começamos a fazer connects; aqui fazemos uma ligaçao dos nossos sliders as spinboxs que faz com que sempre que aumentarmos o numero num deles no outro tambem aumente.
73-80 -> criamos aqui layouts verticais (QVBoxLayout) e horizontais (QHBoxLayout); os layouts criados foram coluna1, coluna2, coluna3, coluna4, base1, base2 e principal;
82-160 -> aqui colocamos dentro dos nossos layouts os items e widgets criados em cima como os sliders etc.
118-119 -> colocamos todos os layouts dentro da janela criada no inicio do programa; depois na janela->show(); mostra finalmente os programas pois sem isto nao da;
120-121 -> fim do programa

no fim teremos este resultado:
Para fazer o Download do QT:
http://linux.softpedia.com/get/Programming/Widgets/Qt-179.shtml

Para instalar:
abrir consola e:

apt-get install libqt4-assistant libqt4-core libqt4-dbg libqt4-dbus libqt4-designer libqt4-dev libqt4-gui libqt4-help libqt4-network libqt4-opengl libqt4-opengl-dev libqt4-qt3support libqt4-script libqt4-sql libqt4-sql-ibase libqt4-sql-mysql libqt4-sql-odbc libqt4-sql-psql libqt4-sql-sqlite libqt4-sql-sqlite2 libqt4-svg libqt4-test libqt4-webkit libqt4-webkit-dbg libqt4-xml libqt4-xmlpatterns libqt4-xmlpatterns-dbg libqtcore4 libqtgui4 qt4-demos qt4-designer qt4-dev-tools qt4-doc qt4-doc-html qt4-qtconfig

MANIPULAÇÃO DE FICHEIROS BINÁRIOS

2008-10-21T01:12:00.000-07:00

Estamos no fim do modulo 7 e a ultima matéria dada foi a manipulação não em ficheiros de texto mas binários que é mais ao menos igual em termos de formas de abertura;

A sua forma de abertura é simples usamos o "r" ou "w" para ler ou escrever no ficheiro mas adicionamos a letra "b" por exemplo: (fp=fopen(argv[1], "wb").

Por exemplo:

#include <stdio.h>
int main(int argc, char *argv[]){
    int valores[5]={7, 3, 8, 1, 2};
    FILE *fp;
    if ((fp=fopen(argv[1], "wb"))==NULL || argc != 2){
        printf("ERRO!\nModo de utilização: %s nome_ficheiro_dados\n", argv[0]);
        return 1;
    }
    fwrite(valores, sizeof(int), 5, fp);
    fclose(fp);
    return 0;
}

Neste programa:

- este programa escreve dados binarios num ficheiro

- o nome do ficheiro e escrito através da linha de comandos

- e usado o operados sizeof( tipo de dados (int, float, etc.) ) para determinar o número de bytes ocupado por um int.

- e usada a funçao fwrite que representa o número de elementos (dos n) que conseguiu escrever com sucesso.

Em cima foi usado o fwrite agora usaremos o fread para ler o ficheiro que como sabem foram usados caracteres binarios

Aqui, a função fread lê um bloco de dados com um determinado tamanho em bytes do ficheiro para a memória primária.

http://www.4shared.com/file/67765542/7b00e695/binarios_escrever.html

Neste programa:

- é usada a funçao fread para ler os caracteres do ficheiro anterior por exemplo

- o nome do ficheiro é escrito através da linha de comandos

- O valor de retorno da função fread representa o número de elementos (dos n) que conseguiu ler com sucesso.

E agora sim acabou o modulo 7 e a manipulaçao de ficheiros espero ajudar

Obrigado
TG

2008-10-20T01:09:00.000-07:00

Bem no ultimo post fiquei-me pela leitura de ficheiros caracter-a-caracter e como disse aqui estou com um post de continuação.
Agora vou falar de leitura de Ficheiros de texto com a leitura/escrita formatada, onde usaremos as variáveis fprintf e fscanf.

fprintf - esta variavel escreve dados num ficheiro num formato indicado e só devem ser utilizadas em ficheiros de texto.

Como exemplo de fprintf têm agora um programa básico sobre isto:

#include <stdio.h>
int main(int argc, char *argv[]){

  FILE *fp;

  int a=1;
  char b[30]="maria";
  float c=2.3;

  if(argc == 2){
    fp = fopen(argv[1], "w");
    fprintf(fp, "%d %s %.1f", a, b, c);
    fclose(fp);
  }
  else
    printf("É necessário especificar um nome de ficheiro.\n");
  return 0;
}

Neste programa:
- o nome do ficheiro e digitado através da linha de comandos ao compilar por exemplo: "./fprintf dados.txt"
- o programa grava no ficheiro "dados.txt" as palavras: "1 maria 2.3"
- e aberto no modo de escrita ("w")

Agora o fscanf; Com esta variavel, entramos no ficheiro e lê-mos os dados que existem lá.
Por exemplo:

#include <stdio.h>
int main(int argc, char *argv[]){

  FILE *fp;

  int a;
  char b[30];
  float c;

  if((fp = fopen(argv[1], "r"))!=NULL){
    fscanf(fp, "%d %s %f", &a, b, &c);
    printf("a = %d\n", a);
    printf("b = %s\n", b);
    printf("c = %.1f\n", c);
    fclose(fp);
  }
  else
    printf("O ficheiro especificado não existe!\n");
  return 0;
}

Neste programa:
- o ficheiro e aberto através da linha de comandos como o exemplo acima.
- é aberto no modo de leitura ("r").
- Devolve o número de parâmetros que conseguiu ler com sucesso
- Se o ficheiro não existir ou não se encontrar na mesma pasta/localização o programa avisa que o ficheiro e inexistente.

E acaba aqui a minha introdução a manipulação de ficheiros de texto;

Manipulaçao de ficheiro em linguagem C

2008-10-07T00:43:00.000-07:00

Ano novo matéria nova e modulo 7 ;)
Hoje o meu post vai falar sobre Manipulação de ficheiros. Apesar do assunto se dividir entre duas matérias (manipulação de ficheiros de texto e manipulaçao de ficheiros binarios) apenas vou falar do que aprendi que foi manipulaçao de ficheiros de texto.

Ficheiros de texto são aqueles que contêm caracteres perceptíveis para o ser humano (que conseguimos entender). São caracteres da tabela ASCII como algarismos, letras do alfabeto, caracteres de acentuação, pontução entre muitos outros.
Começamos por aprender a abrir e fechar ficheiros atraves de "fopen" e "fclose"

fopen é uma operação que consiste em mandar o programa aceder ao ficheiro, associando-o a uma variável (ficheiro p.ex.);
Para poder abri-lo também é necessário indicar o nome do ficheiro existente na mesma pasta onde esta gravado o programa (“dados.txt” p.ex.) e o modo de abertura que pode ser:
"r" - leitura do ficheiro (permite ler mas nao escrever)
"w" - escrita (permite escrever mas nao ler)
estes foram os mais usados apesar de existirem mais foi os unicos que usamos para ja.

fclose vai eliminar a ligação criada entre o programa e a variável associada ao ficheiro (antes de o fazer verifica que os dados foram gravados).

Para ajudar a perceber clique aqui para fazer o download de um programa basico sobre isto

Depois disto começamos a fazer a leitura de texto no ficheiro atraves da abordagem byte-a-byte ou caracter a caracter. Isto basea-se nas funçoes fgetc e fputc.

fgetc:

http://www.4shared.com/file/65977933/70a028c2/manipulaao_ficheiros.html

Neste programa:

O ficheiro é aberto no modo de leitura mas como nao e perguntado nada parte-se do princípio que o ficheiro existe e ja esta criado com o nome "texto.txt".

Cada caracter lido não é armazenado numa variável, sendo utilizado apenas na condição do ciclo “while”.

Foi utilizado um ciclo “while” para percorrer o ficheiro byte-a-byte, utilizando a constante simbólica EOF para controlar o fim do ficheiro (EOF=End Of File, cujo valor é -1).

No final este programa conta os caracteres escritos no ficheiro "texto.c".

fputc:

A variavel fputc armazena um caracter ou uma cadeia de caracteres num ficheiro.

http://www.4shared.com/file/65978703/970465d/manipulaao_ficheiros2.html

Neste programa:

O ficheiro é aberto no modo de escrita “w”, assim, caso não exista será criado, e caso exista será substituído.

A string é percorrida caracter-a-caracter até ser detectado o seu terminador, ou seja, o caracter ”.

A instrução fputc(texto[i++], fp); primeiro escreve o caracter no ficheiro, e de seguida incrementa o valor de i.

Basicamente foi isto que aprendemos nas ultimas aulas e que foi testado na prova pratica da ultima semana pode e nao ter corrido muito bem :P

Mais a frente irei publicar outro post com outras noções mas para ja fico.me por aqui

(07-10-08)

Estruturas

2008-06-02T01:22:00.000-07:00

Devido à minha má nota na disciplina de programação, o meu professor mandou-me criar um pequeno post sobre estruturas.

Sabe-se que algoritmos manipulam dados. Quando estes dados estão organizados de forma coerente, sao chamados de estrutura de dados. São a organização e os métodos que manipulam esta determinada estrutura que lhes conferem singularidade. As estruturas de dados são chamadas tipos de dados compostos que se dividem em dois: homogéneos (vectores e matrizes) e heterogéneos (registos). As estruturas homogéneas são conjuntos de dados formados pelo mesmo tipo de dado primitivo. As estruturas heterogéneas são conjuntos de dados formados por tipos de dados primitivos diferentes (campos do registo) numa mesma estrutura.
Basicamente, uma estrutura de dados consiste num grupo de elementos de dados agrupados sob uma designação ou nome. Estes elementos de dados, cuja designação técnica é membros, têm vários tipos e tamanhos distintos. As estruturas de dados são declaradas em C++ utilizando a seguinte sintaxe:
struct nome_da_estrutura{.
o que significa que depois de declararmos o código acima, estamos a criar um novo tipo de dados que podia por exemplo ser struct agenda{int idade; float morada} onde criamos a estrutura agenda que contem os membros idade e morada .
Aqui está um programa que exemplifica isto:
http://www.4shared.com/file/49816311/d82a82d3/novo_struct.html

linha a linha
linha 6: cria uma estrutura chamada NomeCompleto
linha 7, 8, 9: declara uma variavel char de tamanho 15 em todas as linhas
linha 12: cria uma estrutura chamada Pessoa
linha 13: dentro da estrutura NomeCompleto, é criada mais uma chamada Nome
linha 14: é declarada a variavel inteira "idade"
linha 17: dentro da estrutura Pessoa e criada outra chamada total
linha 28: é mostrado o nome completo

se quiserem saber mais um pouco sobre isto, têm aqui alguns sítios:
http://gracianotorrao.wordpress.com/2008/04/01/estruturas-de-dados-struct-c/
http://www.vivaolinux.com.br/scripts/verScript.php?codigo=1955
http://pt.wikibooks.org/wiki/Programar_em_C/Tipos_de_dados_definidos_pelo_usu%C3%A1rio
http://www.linuxdicas.com.br/section-viewarticle-219.html

Exercício:
Depois desta explicação, vou agora propor um pequeno exercício, cujo resultado já foi postado no meu blog. consiste em criar uma pequena agenda onde é criada a estrutura "registo" contendo as variáveis estado, numero de telemóvel, nome, e-mail e data de nascimento. esta agenda deve conter as funções de inserir, eliminar, listar e procurar.
para quem achar difícil, está aqui a resolução:
http://www.4shared.com/file/49091731/ace1b998/_2__agendaTiagoGraa.html

Apontadores

2008-05-29T01:02:00.000-07:00

Nas últimas aulas de programação, foi muito abordado o termo "apontadores" que vou agora muito resumidamente explicá-los.
Um apontador é uma variável que é utilizada para armazenar o endereço de memória de outra variável. Por exemplo, quando escrevemos "int x=1" o número 1 pode ficar guardado no endereço 101 da memória.
Com apontadores, quando escrevemos "*ptr_x=&x" criámos um apontador "ptr", cujo conteúdo foi automaticamente iniciaado com o valor correspondente ao endereço de memória da variável x, que era 101.
Basicamente é isto, mas para uma explicação mais aprofundada entre neste link:
Graciano torrao's deblog.