AC303

ac303.cpp

#include <iostream>
#include <cstdio>
#include <iomanip>
#include <cstdlib>

#define MAX_SIZE 	1000
#define UNDEFINED 	-1

using namespace std;

//Prototipos das funcoes
FILE * abreArquivo();
int charToInt(char a);
int leVetor(FILE * pFile, int vet[]);

//=== MAIN ====//
int main(void)
{
	//Fixa a precisao das casas decimais.
	cout << fixed << showpoint;
	cout << setprecision(4);
	
	FILE * pFile;			//Cria o ponteiro p/ o arquivo
	int vetCorrente[MAX_SIZE];	//Cria vetor com os valores das correntes
	int vetTensao[MAX_SIZE];	//Cria o vetor com os valores das tensoes 
	int tamanhoVetorCorrente;	//Variavel que armazena o numero de correntes lidas
	int tamanhoVetorTensao;		//Variavel que armazena o numero de tensoes lidas
	int i;				//Variavel p/ controle nas iteracoes dos fors
	float valorToralKWh = 0;	//Variavel p/ armazenar o total de KH consumidos
	
	pFile = abreArquivo();					//Abre o arquivo
	tamanhoVetorCorrente = leVetor(pFile, vetCorrente);	//Obtem os valores das correntes
	tamanhoVetorTensao = leVetor(pFile, vetTensao);		//Obtem os valores das tensoes
	
	
	//Se a quantidade de correntes lidas for diferente da quantidade de tensoes, existe uma inconsistencia no arquivo.
	if(tamanhoVetorCorrente != tamanhoVetorTensao)
	{
		cout<<"Arquivo invalido!\n";
		cout<<"A quantidade de tensoes informadas diverge da quantidade de correntes.\n";
		getchar();
		getchar();
		return 0;
	}
	
	//Realiza a as multiplicacoes, calculando a potencia toral em W (Watts)
	for(i = 0; i < tamanhoVetorCorrente; i++)
	{
		valorToralKWh += vetCorrente[i]*vetTensao[i];
	}
	
	//Convete o valor, até então em W, para KWH
	valorToralKWh = valorToralKWh / 1000;	
	
	//Exibe o resultado
	cout<<"Consumo = "<<valorToralKWh<<"KWh\n";
	
	getchar();
	getchar();
}



//=== Abre Arquivo ===//
FILE * abreArquivo()
{
 /***********************************************************
  *  Valida e abre o arquivo escolhido pelo usuário.        *
  * No final a funcao retorna o ponteiro do arquivo aberto. *
  ***********************************************************/
	
	char nomeArquivo[80];		//Inicializa o vetor que irá conter o nome do arquivo
	FILE * pFile;			//Inicializa um ponteiro de arquivo
	
	pFile = (FILE*) malloc(sizeof(FILE));	//Reserva memória p/ o arquivo
   
	while(true)
	{
		cout<<"Informe o nome do arquivo."<<endl;
		cin>>nomeArquivo;
		cout<<endl;
      
		//Tenta abrir o arquivo escolhido em modo leitura
		if ((pFile = fopen(nomeArquivo,"r"))==NULL)
		{ 
			//Caso não seja possível, retorna o ero gerado.
			perror ("Error opening file");
		}
		else
		{
			break;
		}
		cout<<endl;
   }
   return pFile;
}



//=== Char To Int ===//
int charToInt(char a)
{
 /************************************************
  * Converter um caracter passado como parametro *
  * p/ inteiro e retorna este inteiro.           *
  ************************************************/
	return (a - '0');
}



//=== Le Vetor ===//
int leVetor(FILE * pFile, int vet[])
{
 /********************************************************
  * Lê uma linha inteira do arquivo, convete os valores   *
  * lidos e os atribui ao vetor passodo como argumento.   *
  * No fim, a função retorna o tamanho utilizado do vetor *
  *********************************************************/
	
	int tamanho = 0;	//Cria a variável tamanho, que irá armazenar o tamnho do vetor.
	char ch = 0;		//Cria a variável ch, que ira conter o valor de cada caractere do arquivo.
	int valor = UNDEFINED;	//Cria a variável valor e a inicializa como UNDEFINED (-1). 
				//A variável valor é usada p/ converter os valores lidos em velores inteiros.
	
	
	//Enquanto não for o final da linha
	while(ch != '\n' && ch != '\r') //UNIX like uses '\n'. M$ Windows usus '\r''\n'
	{
		ch = fgetc(pFile);	
		
		// (espaco) ' ' ou '\n' ou '\r' são os 3 possivel valores de ch ao terminar de ler uma sequencia numérica
		if(ch != ' ' && ch != '\n' && ch != '\r' ) 
		{
			//Tranforma a sequencia numérica num calor inteiro
			if(valor == UNDEFINED)
			{
				valor = charToInt(ch);
			}
			else
			{
				valor = valor * 10 + charToInt(ch);
			}
			
		}
		else
		{
			// Caso o algoritmo tenha terminado de ler um sequencia numérica...
			vet[tamanho] = valor;		//O valor descoberto é atribuido a atual posicao do vetor
			valor = UNDEFINED;		//A variavel valor é reiniciada
			tamanho++;			//O vetor cresce uma posicao
		}
	}
	
	return tamanho;
}