Classes que Armazenam Coleções de Valores

Classes que Armazenam Coleções de Valores

1. Introdução

! Em algumas situações da prática do programador, uma classe precisa armazenar uma coleção de dados. Ou seja, um dos atributos dessa classe poderia ser representado ou imaginado como sendo um array ou matriz.! Por exemplo, vamos supor que um programador deseje projetar e implementar uma classe que represente a operação de Associação Série e Paralela de resistores elétricos. Primeiramente, essa classe precisaria conhecer quais são os valores dos resistores que serão utilizados nessa associação e ter a capacidade de processá-los. Uma associação de resistores pode ser realizada com dois ou mais resistores.! Esses valores valores de resistores, por sua vez, poderiam ser representados por um simples array na programação procedural. Por exemplo, um array de valores double para representar um conjunto exemplo de valores de resistores poderia ser definido da seguinte forma:

double resistores[ ] = { 100.0, 200.0, 300.5, 400.0, 500.8}

! O valor da associação série “R(serie)” pode ser determinada pela soma dos resistores envolvidos na associação. O valor da associação paralela “R(paralela)”, por sua vez, pode ser determinada pela soma dos inversos desses valores. Por exemplo:

! Para ilustrar como um array pode ser definido e manipulado de dentro de uma classe, este trabalho irá apresentar a representação de uma classe que permite armazenar os valores dos resistores que precisam ser associados em série e paralelo. Nesse exemplo, duas opções de solução de armazenamento desses valores será utilizada, a saber:* alocação dinâmica de memória.* uso da API std::vector

Departamento Acadêmico de EletrônicaDisciplina : IF62C

professor: Robinson Vida NoronhaAssunto: Classes que Armazenam Coleções

Linguagens utilizadas: UML e C++==================================================================================

Wednesday, April 15, 2015 página: 1 / 35

! Essas duas opções de armazenamento serão ilustradas em duas classes chamadas “AssociacaoResistores”. Para diferenciar essas duas classes, será feito o uso de namespaces específicos para cada uma das duas implementações. O exemplo de definição de classe que fará o uso da API std::vector será definida no namespace comVector. O exemplo de definição de classe que NÃO fará o uso da API std::vector será feito no namespace semVector. ! Definido o namespace, surge uma pergunta: O que essa(s) classe(s) poderia(m) conter? Para responder a essa pergunta, será empregado o Diagrama de Casos de Uso na tentativa de definir algumas funcionalidades da classe.

2. Definição do Diagrama de Casos de Uso - DCU da Classe:! Inicialmente, um programador buscaria identificar o que um possível usuário da classe “AssociacaoResistores” poderia fazer com ela. Como a classe poderia ser utilizada? O Diagrama de Caso de Uso da Figura 1, exemplifica uma possível definição.





Figura 1 - Diagrama de Casos de Uso (DCU) de uma classe que calcula a associação de resistores.!! Os Casos de Uso exemplificados na Figura 1, são listados a seguir:* Chamar o construtor: nesse caso, as variáveis ou atributos da classe devem ser

inicializadas com valores padrão.* Guardar um valor de resistor: nesse caso, um valor de resistor é armazenado na

classe.* Acessar o array de resistores guardados: nesse caso, o usuário da classe receberá

um array com os valores dos resistores armazenados.* Guardar um array de valores de resistor: nesse caso, um conjunto de valores é

armazenado na classe.* Acessar um valor de resistor armazenado: nesse caso, o usuário da classe pode

acessar um valor específico armazenado na classe.* Definir a quantidade de resistores que serão armazenados: nesse caso, o usuário

da classe pode definir, a priori, a quantidade de resistores que serão armazenados.* Acessar o valor da quantidade de resistoes da associação: nesse caso, o usuário

tem acesso à quantidade de resistores guardados na classe.* Calcular a resistência equivalente série: nesse caso de uso, a classe fornece ao seu

usuário o valor calculado da associação em série de resistores.* Calcular a resistência equivalente paralela : nesse caso de uso, a classe fornece ao

seu usuário o valor calculado da associação em paralelo de resistores.* Imprimir: nesse caso de uso, a classe imprime a lista de valores de resistores

armazenados e também imprime o valor calculado das resistências equivalentes.

! Após definir o DCU da classe, deve-se elaborar um possível diagrama dessa classe. A Figura 2 ilustra o diagrama dessa classe. Cada Caso de Uso ilustrado na Figura 1 deve ter alguma correspondência ou relação com os métodos da classe a ser implementada. A Tabela 1, a seguir, apresenta uma possível relação.





Tabela 1 - Relacionamento entre os diagramas de caso de uso da classe e os métodos da classe.

Caso de Uso Método da Classe





Caso de Uso Método da Classe

Figura 2 - Diagrama da Classe AssociacaoResistores

! A definição da linguagem de implementação, em alguns casos, requer a definição e execução de pequenas modificações ou adaptações no diagrama de classes. A





quantidade de modificações é diretamente proporcional à escolha da implementação. As Figuras 3 e 4 apresentam essas modificações para os cenários de uso ou não da classe std::vector para armazenar os valores dos resistores. ! Para a implementação do namespace semVetor deve-se definir métodos e atributos específicos para a manipulação do array de valores. A Figura 3 ilustra essa modificação. ! O atributo inteiro quantidadeGuardado inserido na Figura 3, refere-se à quantidade de resistores efetivamente guardados no array. ! Um usuário da classe pode definir que um objeto dessa classe deve ter capacidade de armazenar 4 valores. Essa informação fica guardada no atributo do tipo inteiro quantidadeResistores e é utilizada para determinar a quantidade de memória a ser alocada. ! Esse usuário também deve ser capaz de inserir valores dos resistores no array de maneira isolada ou em grupo. A cada valor inserido, o valor do atributo quantidadeGuardado deve ser incrementado. ! Quando a quantidade de valores de resistor inseridos (quantidadeGuardado) for superior à quantidade definida pelo usuário ( quantidade ), nova memória precisará ser alocada. Essa expansão da memória alocada é real izada pelo método “realoqueMemória(int p)”.! O método “realoqueMemória(int p)” define instruções que ampliam a quantidade de memória reservada. Essa ampliação permite guardar novos valores de resistores. Como esse método é um método específico para essa implementação, ele tem o seu identificador de acesso definido para privado ( sinal de “-” no diagrama da classe ). Não há a necessidade que algum usuário da classe faça essa manipulação do tamanho do array, por isso, o método é definido como privado.





Figura 3 - Diagrama da Classe AssociacaoResistores do namespace semVector para implementação em C++

! A definição da classe para o namespace “comVetor”, ilustrada na Figura 4, por sua vez, apresenta algumas simplificações na sua definição quando comparada com a definição do namespace “semVetor” da Figura 3.! A primeira delas refere-se ao atributo quantidadeGuardado, que representa a quantidade de resistores efetivamente guardado na classe, e ao atributo quantidadeResistores, que representa a quantidade de memória que alocada para guardar os valores de resistores. Nesse novo contexto, esses atributos são desnecessários e devem ser eliminados da representação.! A classe std::vector faz a gerência dessas duas informações por dois métodos da classe. O método size() informa a quantidade de resistores armazenados e o método capacity(), informa a sua capacidade de armazenamento. ! Por consequência disso, os métodos que manipulam esses atributos também são desnecessários. Nesse caso, os métodos setQantidadeResistores(int) e realoqueMemoria(int) podem ser retirados do diagrama da classe juntos com os atributos quantidade e quantidadeGuardado. O diagrama simplificado é apresentado na Figura 4, a seguir.





Figura 4 - Diagrama da Classe AssociacaoResistores do namespace comVector para implementação em C++

! Definidos os diagramas nas Figuras 3 e 4, as próximas seções apresentam as implementações e os testes dessa classe. Inicialmente, a Seção 3 apresenta a implementação da classe do namespace “semVector”. A Seção 4, por sua vez, a implementação do namespace “comVector” é apresentado. Finalizando esse material, um exemplo de uso dessas classes é definido.





3. O namespace semVector:! Para a implementação da classe definida na Figura 3, foi utilizado o aplicativo Eclipse. Após a definição de um projeto C++ no Eclipse, a definição da classe gerada pelo Eclipse é apresentada a partir da Seção 3.1. Nas seções seguintes, de maneira incremental, o programa ganhará forma.

Figura 3 - <reapresentação> Diagrama da Classe AssociacaoResistores do namespace semVector para implementação em C++





3.1 Arquivo “.h” - Definição da Classe

Tabela 2 - Definição da Classe - AssociacaoResistores.h

#ifndef ASSOCIACAORESISTORES_H_#define ASSOCIACAORESISTORES_H_

namespace semVector{ class AssociacaoResistores { public:! AssociacaoResistores();! virtual ~AssociacaoResistores();

private : };}#endif /* ASSOCIACAORESISTORES_H_ */

3.2 Arquivo “.h” - Definição dos Atributos da Classe

Tabela 3 - Definição dos atributos da Classe - AssociacaoResistor.h


namespace semVector{class AssociacaoResistores {public:! AssociacaoResistores();! virtual ~AssociacaoResistores();

private :! double *valorResistor;! int quantidade;! int quantidadeGuardado;};}#endif /* ASSOCIACAORESISTORES_H_ */





3.3 Arquivo “.h” - Definição dos ConstrutoresTabela 3 - Definição dos construtores da Classe -

AssociacaoResistor.h


namespace semVector{class AssociacaoResistores {public:! AssociacaoResistores();! AssociacaoResistores(double, double);! AssociacaoResistores(double *, int);! virtual ~AssociacaoResistores();


!





3.4 Arquivo “.h” - Definição de métodos de acesso aos atributos da classeTabela 4 - Definição de métodos de acesso aos atributos da classe -

AssociacaoResistores.h



! void setQuantidadeResistores(int);! void setValoresResistores(double *, int);

! int getQuantidadeResistores();! double * getValoresResistores();

void addValorResistor(double ); double getValorResistor(int);






3.5 Arquivo “.h” - Definição dos outros métodosTabela 4 - Definição dos outros métodos da classe - AssociacaoResistores.h



! void setQuantidadeResistores(int);! void setValoresResistores(double *, int);

! int getQuantidadeResistores();! double * getValoresResistores();

void addValorResistor(double ); double getValorResistor(int); void print();

double calculaSerie(); double calculaParalelo();private :! double *valorResistor;! int quantidade;! int quantidadeGuardado;! void realoqueMemoria(int);};}#endif /* ASSOCIACAORESISTORES_H_ */





3.6 Arquivo “.cpp” - Definição da estrutura do arquivo .cppTabela 5 - Estrutura do arquvio AssociacaoResistores.cpp

#include "AssociacaoResistores.h"#include <stdlib.h> /* necessario para a funcao malloc */#include <iostream> /* necessario para utilizar o std::cout */

namespace semVector{AssociacaoResistores::AssociacaoResistores() { }

AssociacaoResistores::AssociacaoResistores(double r1, double r2){ }

AssociacaoResistores::AssociacaoResistores(double *r, int p) { }

AssociacaoResistores::~AssociacaoResistores() { }

void AssociacaoResistores::setQuantidadeResistores(int x){ }

void AssociacaoResistores::realoqueMemoria(int p){ }

void AssociacaoResistores::setValoresResistores(double *v, int q){ }

int AssociacaoResistores::getQuantidadeResistores(){ }

double * AssociacaoResistores::getValoresResistores() { }

void AssociacaoResistores::addValorResistor(double v) { }

double AssociacaoResistores::getValorResistor(int p) { }

void AssociacaoResistores::print(){ }

double AssociacaoResistores::calculaSerie() { }

double AssociacaoResistores::calculaParalelo(){ }}





3.7 Arquivo “.cpp” - Definição dos métodos construtores e do destrutor da classeTabela 6 - Implementação dos construtores e do destrutor

AssociacaoResistores::AssociacaoResistores() {! // atributos são inicializados this->quantidade=0;! this->valorResistor=NULL;! this->quantidadeGuardado = 0;}

AssociacaoResistores::AssociacaoResistores(double r1, double r2){ // atributos são inicializados! this->quantidade=0;! this->valorResistor=NULL;! this->quantidadeGuardado = 0; // Define a quantidade de resistores da associacao = 2! this->setQuantidadeResistores(2); // adiciona os valores de resistor recebidos como argumento! this->addValorResistor(r1);! this->addValorResistor(r2);}

AssociacaoResistores::AssociacaoResistores(double *r, int p){ // atributos são inicializados! this->quantidade=0;! this->valorResistor=NULL;! this->quantidadeGuardado = 0; // Define a quantidade de resistores da associacao = p! this->setQuantidadeResistores(p); // adiciona os valores de resistor recebidos como argumento! this->setValoresResistores(r,p);}

AssociacaoResistores::~AssociacaoResistores() { // desaloca memória alocada.! free( AssociacaoResistores::valorResistor );}





3.8 Arquivo “.cpp” - Método de acesso setQuantidadeResistores( int )

Tabela 7 - Definição e alocação de memória para armazenar a quantidade de resistores.

void AssociacaoResistores::setQuantidadeResistores(int x){ // verificar se o valor informado é maior que zero if ( x > 0) { // armazena a quantidade x passada como argumento AssociacaoResistores::quantidade = x;

// aloca espaço de memória AssociacaoResistores::valorResistor =! ! (double *) malloc(AssociacaoResistores::quantidade * sizeof(double));

} // caso o valor de x seja menor ou igual a zero. else std::cerr << "Nao foi possivel modificar a quantidade de resistores.";}





3.9 Arquivo “.cpp” - Método de alocação de memória realoqueMemoria( int )

Tabela 8 - Definição do método de realocação de memória do array.

void AssociacaoResistores::realoqueMemoria(int p){ // se p <= 0, retorne e não faça nada! if (p<=0) return;

// define uma variável auxiliar “mais vetores” /* aloca-se espaço para essa variável de (p + quantidade) posicoes*/! double *mais_resistores = (double *) malloc ( (p + this->quantidade) * sizeof(double));

// se a memória foi alocada o ponteiro não aponta para NULL! if (mais_resistores != NULL)! { /* copia o conteudo do array valorResistor para o novo array*/ for (int i = 0; i < this->quantidade ; i++) ! mais_resistores[i] = this->valorResistor[i];

/* faz o atributo da classe valorResistor apontar para esse novo array.*/ this->valorResistor = mais_resistores;

// incrementa o valor da quantidade de “p” posicoes! quantidade += p;}! else { // se a memória não foi alocada, entao, mensagem de erro std::cerr << "erro de alocacao de memoria" << std::endl;}}





3.10 Arquivo “.cpp” - Método de adição de um valor de resistor no array

Tabela 9 - Definição do método de inserção de valor no array.

void AssociacaoResistores::addValorResistor(double v){ // se o valor for igual a inferior a zero, sair da aplicacao if ( v <= 0.0 ) return;

/* se a quantidade de valores a serem armazenados no array ainda não foi definida, defina ela para o valor 1. */ if (this->quantidade == 0) this->setQuantidadeResistores(1);

/* calcula a quantidade de espaço diponível para armazenar o dado*/! int dif = this->quantidade - this->quantidadeGuardado;

/* se a quantidade de espaço disponivel for zero, realoque um espaço de memória */! if (dif == 0) {this->realoqueMemoria(1);}

/* Guarda o valor recebido na última posição guardada*/! AssociacaoResistores::valorResistor[this->quantidadeGuardado] = v;

// incremenda a posição do último elemento guardado! this->quantidadeGuardado ++;

}





3.11 Arquivo “.cpp” - Método de adição de um conjunto de valores no array

Tabela 10 - Definição do método de adição de um conjunto de valores no array

void AssociacaoResistores::setValoresResistores(double *v, int q){ /* valores recebidos : p -> informa quantidade de elemento *v -> ponteiro com a lista de elementos */ /* verifico o valor da quantidade de elementos previamente definida para alocação. Se ela for zero, aloca-se memória para “q” valores */ if (this->quantidade == 0) this->setQuantidadeResistores(q);

/* se a quantidade a ser armazenada (q) for superior ao espaço disponivel (quantidade - quantidadeGuardado), entao realoqueMemoria para ( q - (quantidade - quantidadeGuardada)*/ if ( q > (this->quantidade - this->quantidadeGuardado) ) ! this->realoqueMemoria(q - (this->quantidade - this->quantidadeGuardado));

/* adicione cada um dos valores enviados para a funçao*/ for (int elemento = 0; elemento < q; elemento++) {AssociacaoResistores::addValorResistor( v[elemento] );}}





3.12 Arquivo “.cpp” - Métodos “gets”

Tabela 11 - Definição dos métodos de acesso de leitura (gets) dos atributos da classe

int AssociacaoResistores::getQuantidadeResistores() { return AssociacaoResistores::quantidadeGuardado;}

double * AssociacaoResistores::getValoresResistores() { return AssociacaoResistores::valorResistor;}

double AssociacaoResistores::getValorResistor(int p){ // define uma saída com valor padrão double saida = -1.0;

/* verificar se aposicao solicitada foi guardada. Se sim, modficar o valor da saida. */ if ( p < AssociacaoResistores::quantidadeGuardado)! saida = AssociacaoResistores::valorResistor[p];

// retorna o valor definido pela variável saida. return saida;}





3.13 Arquivo “.cpp” - Métodos de cálculo das associações.

Tabela 12 - Métodos de Cálculo das Associações Série e Paralela de valores de resistores

double AssociacaoResistores::calculaSerie(){ double saida = 0; for (int i = 0; i < AssociacaoResistores::quantidadeGuardado; i++) { saida += AssociacaoResistores::valorResistor[i];} return saida;}

double AssociacaoResistores::calculaParalelo(){ double saida = 0.0;

if (AssociacaoResistores::quantidadeGuardado > 0.0) saida = AssociacaoResistores::valorResistor[0];

for (int i = 1; i < AssociacaoResistores::quantidadeGuardado; i++)! saida = (saida*AssociacaoResistores::valorResistor[i])/(saida + AssociacaoResistores::valorResistor[i]); return saida;}





3.14 Arquivo “.cpp” - Método de impressão

Tabela 12 - Definição do método de impressão

void AssociacaoResistores::print(){! std::cout << "Funcao de Impressao \n Resistores Fornecidos:{\t";

! for (int i = 0; i < quantidadeGuardado; i++)! ! std::cout << this->getValorResistor(i) << "\t";

! std::cout << "} Quantidade de Elementos:" << quantidadeGuardado;

! std::cout << "\n Valor do Resistor Equivalente Série:" << this->calculaSerie() << ” ohms”;

! std::cout << "\n Valor do Resistor Equivalente Paralelo:" << this->calculaParalelo() << ” ohms”;

! std::cout << std::endl;}





3.15 Arquivo “main.cpp” - Exemplo de uso da classeTabela 13 - Exemplo de Uso

#include <iostream>#include "AssociacaoResistores.h"

using namespace std, semVector;

int leiaInteiro(char *t);double leiaDouble(char *t);

int main(){ semVector::AssociacaoResistores ar;

// adiciona resistores de maneira individual - esses valores sao lidos do teclado int q = leiaInteiro("Quantidade de Resistores da Associação?");

ar.setQuantidadeResistores(q); double lido; for (int j = 0; j < q; j++) { lido = leiaDouble("\nDigite o valor do Resistor:"); ar.addValorResistor(lido);}

// define-se, de maneira aleatoria, um conjunto ou colecao de valores. double v[] = {110.2, 120.0, 130.0, 140.0, 150.0, 160.0, 170.0};

// adiciona a colecao. primeiro parametro sao os valores, o segundo a quantidade. ar.setValoresResistores(v, 7);

// adiciona-se mais dois resistores. ar.addValorResistor(500); ar.addValorResistor(11.1);

// vou acessar os valores guardados double *guardados = ar.getValoresResistores(); std::cout << "\n Valores guardados que foram acessados externamento: {"; for (int j = 0; j < ar.getQuantidadeResistores(); j++) std::cout << " " << guardados[j]; std::cout << "}" << std::endl;

std::cout << "Chamada da funcao de impressao da classe:" <<std::endl; ar.print(); std::cout << "*** FIM." << std::endl; return 0;}

int leiaInteiro(char *t){ int saida = -1; std::cout << t; std::cin >> saida; return saida;}double leiaDouble(char *t){ double saida = -1.0; std::cout << t; std::cin >> saida; return saida;}





4. O namespace comVector:! Para a implementação da classe definida na Figura 3, foi utilizado o aplicativo Eclipse. Após a definição do projeto C++ no Eclipse, a definição da classe gerada pelo Eclipse é apresentada a partir da Seção 4.1.

Figura 4 - <reapresentacao> Diagrama da Classe AssociacaoResistores do namespace comVector para implementação em C++





4.1 Arquivo “.h” - Definição da Classe

Tabela 14 - Definição da Classe - AssociacaoResistores2.h

#ifndef ASSOCIACAORESISTORES2_H_#define ASSOCIACAORESISTORES2_H_

#include <vector> // biblioteca que define a classe vector.

namespace comVector{class AssociacaoResistores {public:! AssociacaoResistores();! virtual ~AssociacaoResistores();

private:};}#endif /* ASSOCIACAORESISTORES2_H_ */

4.2 Arquivo “.h” - Definição dos Atributos da Classe

Tabela 15 - Definição dos atributos da Classe - AssociacaoResistor2.h


#include <vector>

namespace comVector{class AssociacaoResistores {public:! AssociacaoResistores();! virtual ~AssociacaoResistores();

private: // elemento que armazenará os valores de resistores! std::vector<double> lista;};}





4.3 Arquivo “.h” - Definição dos Construtores

Tabela 16 - Definição dos construtores da Classe - AssociacaoResistor2.h


#include <vector>

namespace comVector{class AssociacaoResistores {public:! AssociacaoResistores();! AssociacaoResistores(double , double);! AssociacaoResistores(double *, int);! virtual ~AssociacaoResistores();

private:! std::vector<double> lista;};}

!





4.4 Arquivo “.h” - Definição de métodos de acesso aos atributos da classe

Tabela 17 - Definição de métodos de acesso aos atributos da classe - AssociacaoResistores2.h


#include <vector>


! void setValoresResistores(double *, int); void addValorResistor(double); ! int getQuantidadeResistores();! double * getValoresResistores(); double getValorResistor(int); private:! std::vector<double> lista;};}





4.5 Arquivo “.h” - Definição dos outros métodos

Tabela 18 - Definição dos outros métodos da classe - AssociacaoResistores2.h


#include <vector>


! void setValoresResistores(double *, int); void addValorResistor(double); ! int getQuantidadeResistores();! double * getValoresResistores(); double getValorResistor(int); void print();

double calculaSerie(); double calculaParalelo();private:! std::vector<double> lista;};}





4.6 Arquivo “.cpp” - Definição da estrutura do arquivo .cppTabela 19 - Estrutura do arquvio AssociacaoResistores2.cpp

#include "AssociacaoResistores2.h"#include <iostream>

namespace comVector{

AssociacaoResistores::AssociacaoResistores() { }

AssociacaoResistores::AssociacaoResistores(double r1, double r2){ }

AssociacaoResistores::AssociacaoResistores(double *Rs, int p){ }

AssociacaoResistores::~AssociacaoResistores() { }

void AssociacaoResistores::setValoresResistores(double * v, int q) { }

int AssociacaoResistores::getQuantidadeResistores() {}

double * AssociacaoResistores::getValoresResistores() { }

void AssociacaoResistores::addValorResistor(double v) { }

double AssociacaoResistores::getValorResistor(int p) { }

void AssociacaoResistores::print(){ }

double AssociacaoResistores::calculaSerie() { }

double AssociacaoResistores::calculaParalelo(){ }}





4.7 Arquivo “.cpp” - Definição dos métodos construtores e do destrutor da classe

Tabela 20 - Implementação dos cosntrutores e do destrutor

AssociacaoResistores::AssociacaoResistores() { }

AssociacaoResistores::AssociacaoResistores(double r1, double r2){ this->addValorResistor(r1); this->addValorResistor(r2);}

AssociacaoResistores::AssociacaoResistores(double *Rs, int p){ this->setValoresResistores(Rs, p);}AssociacaoResistores::~AssociacaoResistores() { }

4.8 Arquivo “.cpp” - Método de adição de um valor de resistor no array

Tabela 21 - Definição do método de inserção de valor no array.

void AssociacaoResistores::addValorResistor(double v){ this->lista.push_back(v);}

4.9 Arquivo “.cpp” - Método de adição de um conjunto de valores no array

Tabela 22 - Definição do método de adição de um conjunto de valores no array

void AssociacaoResistores::setValoresResistores(double * v , int q){ for (int i = 0; i < q; i++) this->addValorResistor(v[i]);}





4.10 Arquivo “.cpp” - Métodos “gets”

Tabela 23 - Definição dos métodos de acesso de leitura (gets) dos atributos da classe

double * AssociacaoResistores::getValoresResistores(){! int t = this->getQuantidadeResistores();! double *saida = (double *) malloc( t * sizeof(double));

! for (int i =0; i < t ; i++) saida[i] = this->lista.at(i);

! return saida;}

double AssociacaoResistores::getValorResistor(int p){ return this->lista.at(p);}





4.11 Arquivo “.cpp” - Métodos de cálculo das associações.

Tabela 24 - Métodos de Cálculo das Associações Série e Paralela de valores de resistores

double AssociacaoResistores::calculaSerie(){! double saida = 0.0;! for (int i = 0; i < this->lista.size(); i++)! ! saida += this->lista.at(i); return saida;}

double AssociacaoResistores::calculaParalelo(){! double saida = 0.0; for (int i = 0; i < this->lista.size(); i++) !if (i == 0) saida = this->lista.at(i); !else ! saida = saida * this->lista.at(i) / ( saida + this->lista.at(i) ); return saida;}

4.12 Arquivo “.cpp” - Método de impressão

Tabela 25 - Definição do método de impressão

void AssociacaoResistores::print(){! std::cout << "{\t";! for (int i = 0; i < this->getQuantidadeResistores(); i++)! ! std::cout << this->getValorResistor(i) << "\t";! std::cout << "} Quantidade de Elementos:" << this->getQuantidadeResistores();

! std::cout << "\n Valor do Resistor Equivalente Série:" << this->calculaSerie() << ” ohms”;

! std::cout << "\n Valor do Resistor Equivalente Paralelo:" << this->calculaParalelo() << ” ohms”;}





Tabela 26 - Exemplo de Uso da Classe

#include <iostream>#include "AssociacaoResistores2.h"

using namespace std;using namespace comVector;

int leiaInteiro(char *t);double leiaDouble(char *t);

int main(){ comVector::AssociacaoResistores ar;

// adiciona resistores de maneira individual - esses valores sao lidos do teclado int q = leiaInteiro("Quantidade de Resistores da Associação?");

double lido; for (int j = 0; j < q; j++) { lido = leiaDouble("\nDigite o valor do Resistor:"); ar.addValorResistor(lido);}

// define-se, de maneira aleatoria, um conjunto ou colecao de valores. double v[] = {110.2, 120.0, 130.0, 140.0, 150.0, 160.0, 170.0};

// adiciona a colecao. primeiro parametro sao os valores, o segundo a quantidade. ar.setValoresResistores(v, 7);

// adiciona-se mais dois resistores. ar.addValorResistor(500); ar.addValorResistor(11.1);

// vou acessar os valores guardados double *guardados = ar.getValoresResistores(); std::cout << "\n Valores guardados que foram acessados externamento: {"; for (int j = 0; j < ar.getQuantidadeResistores(); j++)! std::cout << " " << guardados[j]; std::cout << "}" << std::endl;

std::cout << "Chamada da funcao de impressao da classe:" <<std::endl; ar.print(); std::cout << "*** FIM." << std::endl; return 0;}

int leiaInteiro(char *t){ int saida = -1; std::cout << t; std::cin >> saida; return saida;}

double leiaDouble(char *t){ double saida = -1.0; std::cout << t; std::cin >> saida; return saida;}





Figura 5 - Resultado da Execução dos Programas apresentados nas Tabelas 26 e 13





5. Encerrando

! O objetivo deste material era auxiliar o aluno no desenvolvimento das suas habilidades de programador. Para isso, foi desenvolvido em pequeno exemplo de criação e uso de uma classe que permite fazer o cálculo da associação de resistores. ! Apesar da sua caracterítica puramente instrucional, os conceitos apresentados aqui são de suma importância o programados conhecer. Os conceitos apresentados foram:* Alocação dinâmica de memória* Uso da classe std::vector para armazenar uma lista de valores.* Definição e criação de métodos de impressão.* Definição e criação de métodos de acesso.* Definição de vsibilidade pública e privada de atributo e métodos* Uso do Diagrama de Casos de Uso para auxiliar na definição dos métodos da classe.

! Os arquivos fonte estão disponíveis em:* http://www.professorvida.com.br/if62c/vector/AssociacaoResistores.h* http://www.professorvida.com.br/if62c/vector/AssociacaoResistores.cpp* http://www.professorvida.com.br/if62c/vector/AssociacaoResistores2.h* http://www.professorvida.com.br/if62c/vector/AssociacaoResistores2.cpp

! Cabe agora ao aluno, praticar esses conceitos com outros exemplo que ele mesmo poderia imaginar e criar.!





http://www.professorvida.com.br/if62c/vector/AssociacaoResistores.h

http://www.professorvida.com.br/if62c/vector/AssociacaoResistores.h

http://www.professorvida.com.br/if62c/vector/AssociacaoResistores.cpp

http://www.professorvida.com.br/if62c/vector/AssociacaoResistores.cpp

http://www.professorvida.com.br/if62c/vector/AssociacaoResistores2.h

http://www.professorvida.com.br/if62c/vector/AssociacaoResistores2.h

http://www.professorvida.com.br/if62c/vector/AssociacaoResistores2.cpp

http://www.professorvida.com.br/if62c/vector/AssociacaoResistores2.cpp

Classes que Armazenam Coleções de Valores

Documents

Transcript of Classes que Armazenam Coleções de Valores