terça-feira, 31 de julho de 2012

Estrutura de dados - Vetor

Em C existem vetores unidimensionais e bidimensionais, ambos são estruturas homogenias ordenadas e que podem assumir um número de elementos finitos.

Para declarar um vetor, usa-se o a seguinte notação:

tipo nome_vetor [intervalo]

O menor elemento do vetor é chamado limite mínimo e, em C, é sempre 0, e o maior elemento é chamado limite máximo. O número de elementos no vetor é chamado de faixa, a faixa pode ser obtida com limite máximo - limite mínimo - 1 = faixa. 

Em C os limites não podem serem alterados durante a execução do programa, o limite mínimo é sempre fixado em 0, o limite máximo é fixado quando é escrito. Uma técnica que muitos programadores utilizam para simplificar a manutenção do código, é o emprego de um identificador de constante.

//sem idenficador
int main() {
   
    int vetor[100];
   
    return 0;
}
#define LIM 100

int main() {

    int vetor[LIM];

    return 0;
}


Vetores como parâmetros

Como uma variável vetor em C é um ponteiro, os parâmetros vetores são passados por referência em vez de por valor. O conteúdo de um vetor não é copiado quando passado como um parâmetro, em vez disso é passado o seu endereço de memória.

A passagem por referência é muito mais eficiente, já que ela poupa espaço e tempo. Espaço porque não há necessidade de uma segunda cópia do vetor, já que este será modificado diretamente, com isso há um ganho de tempo.


#include <stdio.h>
#define SIZE 10

//PERCEBA QUE NÃO É NECESSÁRIO A PASSAGEM DO TAMANHO DE MEU VETOR
void _preencheVetor(int []);

void _preencheVetor(int v[]) {
    int i;

    for(i = 0; i < SIZE; i++) {v[i] = 1;}
}

void _exibeVetor(int v[]) {
    int i;

    for(i = 0; i < SIZE; i++) {printf("%d\t", v[i]);}
}

int main() {

    int v[SIZE];

    _preencheVetor(v);

    _exibeVetor(v);

    return 0;
}

Cadeia de caracteres (String) em C

Em C uma string é definida como um vetor de caracteres. O carácter NULL é responsável por encerrar uma string, esse caractere é inserido automaticamente ao final de toda string. O caractere NULL é representado pela sequencia de escape \0.
Uma string tem limite minimo igual a 0 e seu limite máximo é o número de caracteres na string. Exemplo:
"Guilherme" é um vetor de 10 elementos (a tecla de escape é contada).

Operações com Strings

Agora vamos implementar algumas operações para manipular Strings.
  1. Encontrar o tamanho da string (strlen);
  2. Concatenar strings (strcat).

int strlen(char []);

int strlen(char array[]) {
    int i;

    for(i = 0; array[i] != '\0'; i++)
        return i;
}

int main() {

    char array[100];

    printf("\nNúmero de elementos = %d", strlen("GUILHERME"));

    return 0;
}

#include <stdlib.h>

char *concat(char *s1, const char *s2)
{
    char *ps1 = s1;

    while(*ps1)
        ps1++;

    while(*ps1++ = *s2++);

    return s1;
}

int main(int argc, char *argv[])
{
    char nome[10] = "Guilherme";
    char sobrenome[10] = " Carvalho";
    char *resultado = concat(nome, sobrenome);
   
    printf("%s\n\n", resultado);
 
    return 0;
}

Vetores bidimensionais

O tipo dos componentes de um vetor pode ser outro vetor. Por exemplo, podemos definir:

int m[3][5];

Isso define um novo vetor contendo três elementos. Cada um desses elementos é em si mesmo um vetor contendo cinco inteiros. Um elemento desse vetor é acessado especificando-se dois índices: um número de linha e um número de coluna.

Próximo assunto -> Lista

domingo, 22 de julho de 2012

Estrutura de dados - Ponteiros

O ponteiro nada mais é do que uma variável que guarda o endereço de memória, ou seja, ela aponta para um determinado espaço que foi alocado na memória. A declaração de ponteiros é feita das três seguintes formas:

  1. permitem a modificação de argumentos de funções: Permite que as funções altere valores de variáveis não globais e não locais e ela através da referência ao endereço de memória da variável passada como parâmetro para a função;

    #include <stdio.h>

    void _f_modifica(int *); ///assinatura da função

    void _f_modifica(int *p) {
        *p = 5;
    }

    int main() {

        int i;

        i = 10;

        printf("\nValor de i = %d", i);

        _f_modifica(&i); //passando o endereço de meḿória da variável i

        printf("\nValor de i = %d", i);

        return 0;
    }

  2. Permitem o uso de rotinas de alocação dinâmica de memória: alocação e desalocação de memória em tempo de execução conforme a necessidade do programa;

    char *ptr;
    ptr = malloc (1);

  3. Aumento de eficiência em determinadas rotinas. A forma de declaração de uma variável ponteiro é:

    tipo *nome_variável
    Onde tipo é o tipo de variável apontada pela variável ponteiro.


Próximo assunto -> Vetor



Tipo de dado abstrato TDA

TDA ou tipo de dado abstrato significa um conjunto de valores e uma sequencia de operações sobre estes valores. Isto é um modelo matemático pelo par (V, O), onde V é um conjunto de valores e O é um conjunto de operações sobre estes valores.

Exemplo:

Dicionário Inglês-Português
  • V: conjunto de pares de palavras;
  • O: inserção de um novo par, remoção de um par, consulta palavra, alteração de palavra.
Um TDA permite definir, além dos dados que serão manipulados por uma estrutura de dado, as operações a executar nos dados representados. Diferentes operações podem ser executadas, tais como operações para criar e eliminar estruturas de dados, operações para inserir, alterar e eliminar elementos das estruturas de dados, e operações para acessar elementos na estrutura de dados.
Não é necessário conhecer ou depender da implementação de um TDA para utilizá-lo, mas, apenas sua interface (conjunto de operações válidas). O TDA é uma técnica muito útil para os programadores que queiram usar certas propriedades matemáticas que não existam na linguagem que eles usam ou usar um tipo de dado de maneira correta.

Próximo assunto -> Ponteiro

Estrutura de dados - Introdução

O que são Estrutura de dados?


Estruturas de dados são estruturas que tem o propósito de armazenar os dados de forma inteligente no computador, fazendo que tais estruturas sejam utilizadas eficientemente na resolução de um problema. Existem inúmeras estruturas que podem ser usadas, porém dependendo do problema a ser solucionado algumas estruturas serão mais indicadas do que outras.

Por que estudar Estruturas de dados?


Essa pergunta é feita com muita frequência já que hoje as linguagens de alto nível oferecem essas estruturas todas prontas, porém, se você é um desenvolvedor que se limita apenas a conhecer as estruturas presentes na API da linguagem que você trabalha infelizmente você estará amarrado a ela, pois você adquiriu conhecimento em uma linguagem e não nas estruturas que compõem a linguagem. Supomos que você tenha que mudar de linguagem de programação e essa nova linguagem não oferece nenhuma estrutura de dados pronta, e ai? E se você não conhece o funcionamento da estrutura como você estará apto a tomar a decisão de qual a melhor estrutura utilizar em um determinado problema? São nessas horas que o conhecimento se faz necessário!


Próximo assunto -> Tipo de dado abstrato (TDA).



Estrutura de dados - Apresentação

Olá pessoal, conheça a nova seção do blog programando onde iremos aprender sobre estrutura de dados. Será utilizada a linguagem C no decorrer deste mini-curso, podendo haver exemplos em Java e Python, porém, C é a linguagem que utilizaremos como padrão.

Abaixo está descrita a grade de nossa seção, aproveitem para se orientar em seus estudos e boa sorte.

  1. O QUE É ESTRUTURA DE DADOS
  2. TDA
  3. PONTEIRO
  4. VETOR
  5. LISTA
  6. PILHA
  7. FILA
  8. ÁRVORE
  9. ÁRVORES ORDENADAS
  10. ÁRVORES ORIENTADAS
  11. ÁRVORE LIVRE
  12. PROGRESSÃO DE ÁRVORES
  13. REPRESENTAÇÃO LIGADA DE ÁRVORES
  14. ÁRVORE BINÁRIA
  15. FUNÇÃO MALLOC
  16. FUNÇÃO CALLOC
  17. FUNÇÃO FREE
PS: Devido a falta de tempo o mini-curso de banco de dados foi adiado para o mês que vem, abraços.

quarta-feira, 18 de julho de 2012

Programando em Java - parte 8

Construtor

Um construtor permite que um determinado trecho de código seja executado toda vez que um objeto é criado, ou seja, toda vez que o operador new é chamado. Assim como os métodos, os construtores podem receber parâmetros. Contudo, diferentemente dos métodos, os construtores não devolvem resposta.
Em Java, um construtor deve ter o mesmo nome da classe na qual ele foi definido:
class CartaoDeCredito {
    int numero ;
    CartaoDeCredito ( int numero ) {
        this . numero = numero ;
    }
}


Na criação de um objeto com o comando new, os argumentos passados devem ser compatíveis com a lista de parâmetros de algum construtor definido na classe que está sendo instanciada. Caso contrário, um erro de compilação ocorrerá para avisar o desenvolvedor dos valores obrigatórios que devem ser passados para criar um objeto.

CartaoDeCredito c = new CartaoDeCredito(736723672);


Construtor Padrão

Toda vez que um objeto é criado, um construtor da classe correspondente deve ser chamado. Mesmo quando nenhum construtor for definido explicitamente, há um construtor padrão que será inserido pelo próprio compilador. O construtor padrão não recebe parâmetros e será inserido sempre que o desenvolvedor não definir pelo menos um construtor explicitamente.
Portanto, para instanciar uma classe que não possui construtores definidos no código fonte, devemos utilizar o construtor padrão, já que este é inserido automaticamente pelo compilador.

class Conta() {}

Lembrando que o construtor padrão só será inserido pelo compilador se nenhum construtor for definido no código fonte. Dessa forma, se você adicionar um construtor com parâmetros então não poderá  utilizar o comando new sem passar argumentos, pois um erro de compilação ocorrerá.

Sobrecarga de Construtores

O conceito de sobrecarga de métodos pode ser aplicado para construtores. Dessa forma, podemos definir diversos construtores na mesma classe.

class Pessoa {
    String rg ;
    int cpf ;
    Pessoa ( String rg ) {
        this . rg = rg ;
    }
    Pessoa ( int cpf ) {
        this . cpf = cpf ;
   }
}

Quando dois construtores são definidos, há duas opções no momento de utilizar o comando new.

// Chamando o primeiro construtor
Pessoa p1 = new Pessoa ( " 123456 X " ) ;
// Chamando o segundo construtor
Pessoa p2 = new Pessoa (123456789) ;


Construtores chamando construtores

Assim como podemos encadear métodos, também podemos encadear construtores.

class Conta {
    int numero ;
    double limite ;
    Conta ( int numero ) {
        this . numero = numero ;
    }
    Conta ( int numero , double limite ) {
        this ( numero ) ;
        this . limite = limite ;
    }
}


segunda-feira, 9 de julho de 2012

Programando em Java - parte 7

Sobrecarga (Overloading)

Java nos permite criar vários métodos com o mesmo nome desde que tenham parâmetros diferentes. Isso é o que chamamos de sobrecarga de métodos.

A sobrecarga de métodos consiste em criarmos o mesmo método com possibilidades de entradas diferentes. Essas entradas, caracterizadas como parâmetros, devem sempre ser de tipos diferentes, quantidades de parâmetros diferentes ou posições dos tipos diferentes.

Os clientes dos bancos costumam consultar periodicamente informações relativas às suas contas. Geralmente, essas informações são obtidas através de extratos. No sistema do banco, os extratos podem ser gerados por métodos da classe Conta.

class Conta {
    double saldo ;
    double limite ;
    void imprimeExtrato ( int dias ) {
        // extrato
    }
}


O método imprimeExtrato() recebe a quantidade de dias que deve ser considerada para gerar o extrato da conta. Por exemplo, se esse método receber o valor 30 então ele deve gerar um extrato com as movimentações dos últimos 30 dias.

Em geral, extratos dos últimos 15 dias atendem as necessidades dos clientes. Dessa forma, poderíamos acrescentar um método na classe Conta para gerar extratos com essa quantidade fixa de dias.

class Conta {
    double saldo ;
    double limite ;
    void imprimeExtrato () {
        // extrato dos últimos 15 dias
    }
    void imprimeExtrato ( int dias ) {
        // extrato
    }
}

O primeiro método não recebe parâmetros pois ele utilizará uma quantidade de dias padrão
definida pelo banco para gerar os extratos (15 dias).

O segundo recebe um valor inteiro como parâmetro e deve considerar essa quantidade de dias
para gerar os extratos.

Os dois métodos possuem o mesmo nome e lista de parâmetros diferentes. Quando dois ou mais
métodos são definidos na mesma classe com o mesmo nome, dizemos que houve uma sobrecarga
de métodos. Uma sobrecarga de métodos só é válida se as listas de parâmetros dos métodos são
diferentes entre si.

No caso dos dois métodos que geram extratos, poderíamos evitar repetição de código fazendo
um método chamar o outro.

class Conta {
    void imprimeExtrato () {
        this . imprimeExtrato (15) ;
    }
    void imprimeExtrato ( int dias ) {
        // extrato
    }
}


quinta-feira, 7 de junho de 2012

Lista de exercícios - modularização, apontadores e recursividade


algoritmo Banco
    declare
    var Registro Conta{
                nro:numerico
                nome:literal
                saldo:numerico
            }
           
    var vetConta[1..50]:Conta
    var opcao:numerico
   
    opcao <- 0
   
    zerarVetor($vetConta) //passagem por referência
   
    enquanto opcao <> 6 então
        escreva '1-cadastrar 2-remover 3-depositar 4-sacar 5-consultar 6-sair'
        leia opcao
       
        escolha opcao
            caso 1:
                cadastrar($vetConta)
            caso 2:
                remover($vetConta)
            caso 3:
                depositar($vetConta)
            caso 4:
                sacar($vetConta)
            caso 5:
                consultar($vetConta)
        fim_escolha
       
    fim_enquanto
   
fim_algoritmo

subrotina zerarVetor(vetConta[1..50])
    var i:numerico
    para i <- 1 até 50 faça
        vetConta[i].nro <- 0
        vetConta[i].nome <- NULO
        vetConta[i].saldo <- 0
    fim_para
fim_subrotina

subrotina cadastrar(vetConta[1..50)
    var i, aux:numerico
   
    aux <- -1
   
    para i <- 1 até 50 faça
        se vetConta[i].nro = 0 então
            aux <- i
        fim_se
    fim_para
   
    se aux = -1 então
        escreva 'Não há espaço suficiente para realizar um novo cadastro de conta'
    senão
        escreva 'Informe o número da conta:'
        leia vetConta[aux].nro
       
        escreva 'Informe o nome do cliente:'
        leia vetConta[aux].nome
       
        vetConta[aux].saldo <- 0
       
        Escreva 'Conta cadastrada com sucesso!'
    fim_se
fim_subrotina

subrotina remover(vetConta[1..50])
    var i, aux, nro:numerico
   
    aux <- -1
   
    escreva 'Informe o número da conta que deseja remover:'
    leia nro
   
    para i <- 1 até 50 faça
        se nro = vetConta[i].nro então
            aux <- i
        fim_se
    fim_para
   
    se aux = -1 então
        escreva 'Não foi encontrada nenhuma conta com o número informado, por favor verifique o número e repita a operação!'
    senão
        vetConta[aux].nro <- 0
        vetConta[aux].nome <- NULO
        vetConta[aux].saldo <- 0
        escreva 'Conta removida com sucesso!'
    fim_se
fim_subrotina

subrotina depositar(vetConta[1..50])
    var i, aux, nro, valor:numerico
   
    aux <- -1
   
    escreva 'Informe o número da conta:'
    leia nro
   
    para i <- 1 até 50 faça
        se nro = vetConta[i].nro então
            aux <- i
        fim_se
    fim_para
   
    se aux = -1 então
        escreva 'Essa conta não está cadastrada!'
    senão
        escreva 'Informe o valor que deseja depositar:'
        leia valor
       
        se valor > então
            vetConta[aux].saldo <- vetConta[aux].saldo + valor
            escreva 'Depositado realizado com sucesso!'
        senão
            escreva 'Valor inválido!'
    fim_se
fim_subrotina

subrotina sacar(vetConta[1..50])
    var i, aux, nro, valor:numerico
   
    aux <- -1
   
    escreva 'Informe o número da conta:'
    leia nro
   
    para i <- 1 até 50 faça
        se nro = vetConta[i].nro então
            aux <- i
        fim_se
    fim_para
   
    se aux = -1 então
        escreva 'Essa conta não está cadastrada!'
    senão
        escreva 'Informe o valor que deseja sacar:'
        leia valor
       
        se valor > 0 então
            vetConta[aux].saldo <- vetConta[aux].saldo - valor
            escreva 'Saque realizado com sucesso!'
        senão
            escreva 'Valor inválido!'
        fim_se
fim_subrotina

subrotina consultar(vetConta[1..50])
    var i, aux, nro:numerico
   
    aux <- -1
   
    escreva 'Informe o número da conta:'
    leia nro
   
    para i <- 1 até 50 faça
        se nro = vetConta[i].nro então
            aux <- i
        fim_se
    fim_para
   
    se aux = -1 então
        escreva 'Essa conta não está cadastrada!'
    senão
        escreva 'Número: ', nro
        escreva 'Cliente: ', vetConta[aux].nome
        escreva 'Saldo: ', vetConta[aux].saldo
    fim_se
fim_subrotina


quarta-feira, 6 de junho de 2012

Lista de exercícios - modularização, apontadores e recursividade

#include <stdio_ext.h>
struct Conta {
    char nome[100];
    int numero;
    float saldo;
};

void inicializar(struct Conta[50]);
int cadastrar(int, struct Conta[50]);
int remover(struct Conta[50]);
void depositar(struct Conta[50]);
void sacar(struct Conta[50]);
void consultar(struct Conta[50]);

void inicializar(struct Conta contas[50]) {
    int i=0;

    for(i = 0; i < 50; i++) {
        contas[i].numero = 0;
        contas[i].saldo = 0;
    }
}

int cadastrar(int nroContas, struct Conta contas[50]) {
    int i, aux, numero, existe, cadastardoComSucesso;

    existe = 0;
    cadastardoComSucesso = 0;

    if(nroContas<=50) {
        for(i = 0; i < 50; i++) {
            if(contas[i].numero == 0) {
                aux = i;
            }
        }

        printf("\nInforme um número para conta: ");
        scanf("%d", &numero);

        for(i = 0; i < 50; i++) {
            if(numero == contas[i].numero)
                existe = 1;
        }

        if(existe) {
            printf("\nA conta %d já existe!\n", numero);
        }else{
            __fpurge(stdin);
            printf("\nInforme o nome: ");
            gets(contas[aux].nome);
            contas[aux].saldo = 0;
            contas[aux].numero = numero;
            cadastardoComSucesso = 1;
            printf("\nConta cadastrada com sucesso!\n\n");
        }
    } else {
        printf("\nNão há mais espaço para cadastrar novos clientes!\n\n");
    }
    return cadastardoComSucesso;
}

int remover(struct Conta contas[50]) {
    int codigo, i, aux, cadastardoComSucesso;

    aux = -1;
    cadastardoComSucesso = 0;

    printf("\nInforme o número da conta: ");
    scanf("%d", &codigo);

    for(i = 0; i < 50; i++) {
        if(contas[i].numero == codigo)
            aux = i;
    }

    if(aux == -1)
        printf("\nEssa conta não está cadastrada!\n\n");
    else {
        contas[aux].numero = 0;
        contas[aux].saldo = 0;
        cadastardoComSucesso = 1;
        printf("\nConta excluida com sucesso!\n\n");
    }
    return cadastardoComSucesso;
}

void depositar(struct Conta contas[50]) {
    int numero, i, aux;

    aux = -1;

    printf("\nInforme o número da conta: ");
    scanf("%d", &numero);

    for(i = 0; i < 50; i++) {
        if(contas[i].numero == numero) {
            aux = i;
        }
    }

    if(aux == -1) {
        printf("\nEssa conta não está cadastrada!\n\n");
    }else{
        float valor;
        printf("\nInforme o valor que deseja depositar: ");
        scanf("%f", &valor);

        if(valor > 0) {
            contas[aux].saldo = contas[aux].saldo + valor;
            printf("\nDeposito realizado com sucesso!\n");
        }else{
            printf("\nNão é possível depositar um valor negativo ou nulo a sua conta!\n\n");
        }
    }
}

void sacar(struct Conta contas[50]) {
    int numero, i, aux;

    aux = -1;

    printf("\nInforme o número da conta: ");
    scanf("%d", &numero);

    for(i = 0; i < 50; i++) {
        if(contas[i].numero == numero) {
            aux = i;
        }
    }

    if(aux == -1) {
        printf("\nEssa conta não está cadastrada!\n\n");
    }else{
        float valor;
        printf("\nInforme o valor que deseja sacar: ");
        scanf("%f", &valor);

        if(valor > 0) {
            contas[aux].saldo = contas[aux].saldo - valor;
            printf("\nValor sacado com sucesso!\n\n");
        }else{
            printf("\nNão é possível salvar um valor negativo ou nulo!\n\n");
        }
    }
}

void consultar(struct Conta contas[50]) {
    int numero, i, aux;

    aux = -1;

    printf("\nInforme o número da conta: ");
    scanf("%d", &numero);

    for(i = 0; i < 50; i++) {
        if(contas[i].numero == numero) {
            aux = i;
        }
    }

    if(aux == -1) {
        printf("\nEssa conta não está cadastrada!\n\n");
    }else{
        printf("\n\nDADOS DA CONTA %d", aux);
        printf("\nNúmero.: %d", contas[aux].numero);
        printf("\nCliente.: %s", contas[aux].nome);
        printf("\nSaldo.: R$%.2f", contas[aux].saldo);
        printf("\n\n");
    }
}

int main() {
    int opcao=0, nroContas=1, aux, i;
    struct Conta contas[50];

    inicializar(contas);

    while(opcao != 6) {
        printf("1-Cadastramento da conta \n2-Remoção da conta \n3-Depósito \n4-Saque \n5-Consulta\n6-Sair\n: ");
        scanf("%d", &opcao);

        switch(opcao) {
            case 1:
                if(cadastrar(nroContas, contas))
                    nroContas++;
                break;
            case 2:
                if(remover(contas))
                    nroContas--;
                break;
            case 3:
                depositar(contas);
                break;
            case 4:
                sacar(contas);
                break;
            case 5:
                consultar(contas);
                break;
            case 6:
                break;
            default:
                printf("\nA opção digita não existe!\n\n");
                break;
        }
    }

    return 0;
}


#include <stdio_ext.h>
#include <string.h>

struct Filme {
    int codigo, ano;
    char titulo[50], sinopse[100], diretor[50], genero[30];
};

void inicializar(struct Filme[50]);
void cadastrar(struct Filme[50]);
void alterar(struct Filme[50]);
void listarFilmes(struct Filme[50]);
void ordemCrescenteArray(struct Filme[50]);
void procurarFilmePorTitulo(struct Filme[50]);

void inicializar(struct Filme filmes[50]) {
    int i = 0;

    for(i = 0; i < 50; i++) {
        filmes[i].codigo = 0;
        filmes[i].ano = 0;
    }
}

void cadastrar(struct Filme filmes[50]) {
    int aux, i;

    aux = -1;

    for(i = 0; i < 50; i++) {
        if(filmes[i].codigo == 0) {
            aux = i;
        }
    }

    if(aux == -1) {
        printf("\nMemória insuficiente para realizar cadastro\n\n");
    }else{
        int codigo, jaExiste = 0;

        for(i = 0; i < 50; i++) {
            if(filmes[i].codigo == codigo) {
                jaExiste = 1;
            }
        }

        if(jaExiste) {
            printf("\nJá existe um filme cadastrado com o código %d\n\n", codigo);
        }else{
            printf("\nInforme o código: ");
            scanf("%d", &filmes[aux].codigo);

            __fpurge(stdin);
            printf("\nInforme o título: ");
            gets(filmes[aux].titulo);

            __fpurge(stdin);
            printf("\nInforme a sinopse: ");
            gets(filmes[aux].sinopse);

            __fpurge(stdin);
            printf("\nInforme o diretor: ");
            gets(filmes[aux].diretor);

            __fpurge(stdin);
            printf("\nInforme o genêro: ");
            gets(filmes[aux].genero);

            printf("\nInforme o ano: ");
            scanf("%d", &filmes[aux].ano);

            printf("\nFilme cadastrado com sucesso!\n\n");

            ordemCrescenteArray(filmes); //manter o array organizado
        }
    }
}

void alterar(struct Filme filmes[50]) {
    int aux, codigo, i;

    aux = -1;

    printf("\nInforme o código do filme que deseja alterar: ");
    scanf("%d", &codigo);

    for(i = 0; i < 50; i++) {
        if(codigo == filmes[i].codigo) {
            aux = i;
        }
    }

    if(aux == -1) {
        printf("\nEsse filme não está cadastrado!\n\n");
    }else{
        __fpurge(stdin);
        printf("\nInforme um novo título para o filme: ");
        gets(filmes[i].titulo);

        __fpurge(stdin);
        printf("\nInforme uma nova sinopse para o filme: ");
        gets(filmes[i].sinopse);

        __fpurge(stdin);
        printf("\nInforme um novo diretor para o filme: ");
        gets(filmes[i].diretor);

        __fpurge(stdin);
        printf("\nInforme um novo genêro para o filme: ");
        gets(filmes[i].genero);

        __fpurge(stdin);
        printf("\nInforme um novo ano para o filme: ");
        scanf("%d", &filmes[i].ano);

        printf("\nFilme alterado com sucesso!\n\n");
    }
}

void listarFilmes(struct Filme filmes[50]) {
    int i, nroFilmes;

    nroFilmes = 0;

    for(i = 0; i < 50; i++) {
        if(filmes[i].codigo != 0) {
            printf("\nCódigo: %d", filmes[i].codigo);
            printf("\nTítulo: %s" , filmes[i].titulo);
            printf("\nSinopse: %s", filmes[i].sinopse);
            printf("\nGenêro: %s", filmes[i].genero);
            printf("\nDiretor: %s", filmes[i].diretor);
            printf("\nAno: %d", filmes[i].ano);
            printf("\n");
            nroFilmes++;
        }
    }

    printf("\nTotal de filmes: %d\n\n", nroFilmes);
}

void ordemCrescenteArray(struct Filme filmes[50]) {
    struct Filme filme;
    int i;

    for(i = 1; i < 50; i++) {
        if(filmes[i].codigo != 0 && filmes[i-1].codigo != 0) {
            if(filmes[i].ano < filmes[i-1].ano) {
                filme = filmes[i];
                filmes[i] = filmes[i-1];
                filmes[i-1] = filme;
            }
        }
    }
}

void procurarFilmePorTitulo(struct Filme filmes[50]) {
    char titulo[50];
    int i, aux;

    aux = -1;

    __fpurge(stdin);
    printf("\nInforme o titulo que deseja buscar: ");
    gets(titulo);

    for(i = 0; i < 50; i++) {
        if(strcmp(titulo, filmes[i].titulo) == 0) {
            aux = 1;
            printf("\nCódigo: %d", filmes[i].codigo);
            printf("\nTítulo: %s", filmes[i].titulo);
            printf("\nSinopse: %s", filmes[i].sinopse);
            printf("\nDiretor: %s", filmes[i].diretor);
            printf("\nGenêro: %s", filmes[i].genero);
            printf("\nAno: %d", filmes[i].ano);
            printf("\n");
        }
    }
    if(aux == -1) {
        printf("\nEsse filme não está cadastrado!\n\n");
    }
}

int main() {
    int opcao;
    struct Filme filmes[50];

    opcao = 0;

    inicializar(filmes);

    while(opcao != 6) {
        printf("\n1-Cadastrar\n2-Alterar\n3-Listar filmes\n4-Listar filmes por ano\n5-Procurar filme por nome\n6-Sair:");
        scanf("%d", &opcao);

        switch(opcao) {
            case 1:
                cadastrar(filmes);
            break;
            case 2:
                alterar(filmes);
            break;
            case 3:
                listarFilmes(filmes);
            break;
            case 4:
                listarFilmes(filmes);
            break;
            case 5:
                procurarFilmePorTitulo(filmes);
            break;
            case 6:
                printf("\n\nSistema encerrado!!\n");
            break;
            default:
                printf("\nOperação inválida!\n\n");
            break;
        }
    }

    return 0;
}

domingo, 27 de maio de 2012

Programando em Java - parte 6

Métodos

Os métodos são as operações que um objeto é capaz de fazer, ou seja, seu comportamento. Podemos dividir um método em quatro partes:

Nome: É utilizado para chamar o método. Na linguagem Java, é uma boa prática definir os nomes dos métodos utilizando a convenção Camel Case.

Lista de parâmetros: Define os valores que o método deve receber. A lista de parâmetros pode ser vazia, caso não haja nenhum a ser passado.

Corpo: Define o que irá acontecer quando o método for chamado

Retorno: A resposta que será devolvida ao final do processamento do método. Quando o método não devolve nenhuma resposta, ele dever ser marcado com a palavra void.

Suponha que eu queira depositar um dinheiro em minha conta, para isso o método deposita precisaria ser implementado na minha classe Conta:

void deposita(double valor) {
    //Tudo o que está envolvido pelas chaves é considerado corpo do método
    this.saldo += valor;
}
//retorno: void
//nome: deposita
//lista de parâmetros: double valor


Para realizar um depósito, devemos chamar o método deposita() através da referência do objeto que representa a conta que terá o dinheiro depositado.



Conta c = new Conta();
//chamando o método
c.deposita(1000);


Na grande maioria das vezes um método vai ser montado para manter os valores dos atributos do objeto. Dentro de um método, para fazer acesso a um atributo devemos utilizar o comando this.

O método deposita não retorna nenhum valor, por isso o tipo de retorno está definido como void. Um método pode retornar praticamente qualquer tipo de variável. Um exemplo de um método que retorna um valor double.


double exibeSaldo() {
    return this.saldo + this.limite;
}


Agora devemos ter uma variável para armazenar o valor retornado pelo método. Exemplo:


Conta c = new Conta();
c.deposita(1000);

//armazenado o retorno do método em uma váriavel que tenha o tipo de definição igual ao retorno do método chamado
double saldo = c.exibeSaldo();

javax.swing.JOptionPane(null, "Saldo disponivel" + saldo);


Programando em Java - parte 5

POO - Programação Orientada a Objetos

Orientação a objetos é um paradigma de programação, que se relaciona com a ideia de organizar, classificar e abstrair as coisas. 

Domínio e Aplicação

Um domínio é composto pelas entidades, processos e informações Uma aplicação pode ser desenvolvida para tornar fazível as tarefas de um domínio.

Para entender melhor o que é domínio e aplicação, observe o seguinte cenário. Um empresa está desenvolvendo uma solução para um banco:

Domínio = banco
Entidade = clientes, funcionários, agências e contas.
Aplicação = sistema a ser vendido para o banco

Objetos, atributos e métodos

Os objetos são usados para representar as entidades do domínio. As entidades possuem características e essas características são representadas pelos atributos. As entidades também podem executar ações, essas ações são os métodos.

Exemplo:
Entidade = Cliente
Atributo(s) da entidade = nome, rg, cpf;
Método(s) da entidade = fazEmprestimo, mudaEndereco

Classes

Antes de um objeto ser criado devemos definir quais serão seus atributos e métodos. Para realizar essa tarefa fazemos o uso da classe. 

Uma classe é  desenho, projeto de um objeto. Assim como a planta  é um desenho, projeto de uma casa. 

Veja como ficaria a classe conta:
Conta.java
public class Conta { //entidade     double saldo; //atributos     double limite; //atributos     int numero; //atributos }
Agora que já definimos a classe conta, podemos criar objetos a partir dela. Para criar novos objetos é necessário utilizar o comando new.

public class TestaConta { public static void main(String[] args) { new Conta(); } }
Não há nenhum limite para se usar o comando new, ele pode ser usado mais de uma vez no código. Exemplo:

public class TestaConta { public static void main(String[] args) { new Conta(); new Conta(); new Conta(); } }
Tudo foi criado corretamente até agora, porém, se compilarmos o código veremos que nada é exibido. Isso acontece pois os objetos criados não guardam nenhuma referência, e para manipular um objeto é necessário que ele tenha uma referência.

Referências 

A referência de um objeto é a única maneira de acessar seus atributos e métodos. Podemos dizer que a referência funciona como um controle remoto, com o controle conseguimos manipular a TV: aumentamos e diminuímos, ligamos e desligamos, trocamos de canal. 

O comando new, aloca um objeto na memória e retorna uma referência para que possamos acessar aquele objeto. Para guardar essa referencia devemos declarar um avariável do tipo da Classe e ela irá receber o retorno do new, exemplo:

public class TestaConta { public static void main(String[] args) { Conta c = new Conta(); //declara e já recebe a referencia Conta c2; //declara a variável que irá armazenar a referencia c2 = new Conta(); //atribui a referencia do objeto a variável } }
Agora que já temos a referencia, podemos acessar os atributos do objeto. Para acessar os atributos e métodos que estão presentes em nossos objetos utilizamos o operador "." (ponto final).

public class TestaConta { public static void main(String[] args) { Conta c = new Conta(); c.saldo = 1000; //acessando os atributos do objeto com o operador "." c.limite = 100; c.nro = 1; System.out.println("Saldo = R$" + c.saldo); System.out.println("Limite = R$" + c.limite); System.out.println("Número = R$" + c.nro); } }
No código acima o atributo saldo recebe 1000, limite recebe 100 e nro recebe 1. Na sequencia os valores são exibidos para o usuário.

Poderíamos instanciar um objeto e utilizar seus atributos sem inicializa-los explicitamente, pois os atributos são inicializados com valores padrão. Os atributos numéricos são inicializados com 0, os do tipo boolean são inicializados com o tipo false e os demais tipos são inicializados com null (vazio).

Novidade!!! Agora vamos ter canal no Youtube =D

Fala pessoal tudo beleza, estou sumido a correria está forte por aqui. Estou querendo dar um start em um projeto antigo que vem desde o temp...