C++ Vectores e Classes !

Alexander1989

Alexander1989

Power Member
Boas Pessoal !

Estou com dois probleminhas, que espero serem de rápida solução !

Estou a meio de um projecto, que tem duas classes..

O primeiro problema é: Peço ao utilizado para introduzir um nome, uma morada, uma matricula e a classe do veiculo.

Depois esta informação toda terá de ser guardado num vector, mas estes dados tem que ser todos guardados apenas numa posiçao do vector, e nao numa posicao para cada dado introduzido !

Os dados tem que respeitar uma certa formataçao que é a seguinte:

Código: 
[Nome do cliente 1]
[Morada do cliente 1]
[Número do cliente 1][espaço][Matrícula][espaço][Classe do veículo]
[linha em branco]
[Nome do cliente 2]
[Morada do cliente 2]
[Número do cliente 2][espaço][Matrícula][espaço][Classe do veículo]


Porque em seguida vão ser guardados para um ficheiro, com esta formatação !


A minha pergunta é, como eu consigo guardar isto num vector com esta formatação?

Esta Formatação esta definida na classe!
 
Segunda duvida...

Código: 
void escreve_vector_ficheiro(vector<clientes>& vector_clientes, const string& ficheiro_clientes)
{
	ofstream corrente_saida(ficheiro_clientes.data());
	
	corrente_saida.open(ficheiro_clientes.data());

	if(corrente_saida.is_open())
	cout<<" aberto ! \n\n";
	else
	cout<<"Nao consegue abrir o ficheiro de saida!\n";

	clientes escreve_clientes;

	for(unsigned int i=0;i<vector_clientes.size();i++)
		corrente_saida<<vector_clientes[i]<<endl;

	escreve_clientes.escreve(corrente_saida);
	
	corrente_saida.close();
}


A minha pergunta é porque eu não consigo fazer isto:

Código: 
corrente_saida<<vector_clientes[i]<<endl;

Dá-me o seguinte erro:

Código: 
>c:\users\alexandre\documents\visual studio 2008\projects\ciclone\ciclone\funcoes_ciclone.cpp(735) : error C2679: binary '<<' : no operator found which takes a right-hand operand of type 'clientes' (or there is no acceptable conversion)
1>        c:\program files\microsoft visual studio 9.0\vc\include\ostream(653): could be 'std::basic_ostream<_Elem,_Traits> &std::operator <<<char,std::char_traits<char>>(std::basic_ostream<_Elem,_Traits> &,const char *)'


Isto faz parte do mesmo trabalho da duvida anterior! Clientes e uma classe, que tem um escreve definido, com uma verta formatação !
 
das 2 uma, ou fazes o overload de << para poder ser usado pra imprimir a info da class ou metes

corrente_saida<<vector_clientes.x<<endl; onde x é um metodo (ou um membro publico)
 
Em C++ é possível reescrever código para operadores de modo a
manipularem operandos de classe diferente da que estão predefinidos

Esta característica confere uma maior legibilidade aos programas,
particularmente quando se trata de expressões aritméticas envolvendo
tipos definidos pelo programador

Métodos ou funções globais declaradas com a palavra chave operator
associado ao símbolo do operador:

operator @ ( )

promove a sobrecarga desse operador, sendo @ qualquer dos símbolos
susceptíveis de sobrecarga


by Acetatos do ISEP! lol

Exemplo:

Código: 
void Data::escreve(ostream & out) const
{ out << ano << "/" << mes << "/" << dia; }


ostream & operator << (ostream & out, const Data& d)
{ d.escreve(out) ;
return out ; }
Again acetatos ISEP! lol

Cumps
 
blueomega disse:
a classe clientes que variaveis e metodos tem la dentro?

http://www.fredosaurus.com/notes-cpp/oop-friends/overload-io.html
Clicar para expandir...


Código: 
// clientes.h declara a classe clientes.


#ifndef CLIENTES // compila apenas uma vez
#define CLIENTES
#include<iostream>// istream, ostream
#include<string>// string
//#include"ciclone.h"
//#include"ocorrencias.h"
#include<fstream>
#include<vector>

using namespace std;

class clientes
{
public:  // A Interface

// construtores
clientes();
clientes( int num_cliente, string nome_cliente, string morada_cliente, string matricula, string classe_veiculo);

// Entrada/Saida
void le(istream& entrada);
void escreve(ostream& saida) const;


// acessores
int retornaNumCliente();
string retornaNomeCliente() const;
string retornaMoradaCliente() const;
string retornaMatricula() const;
string retornaClasseVeiculo() const;


// operadores relacionais 

//void operator <<(ostream& saida) const;

private: // Atributos
 int m_num_cliente;
string m_nome_cliente; 
string m_morada_cliente;
string m_matricula;
string m_classe_veiculo;
};
#endif

Código: 
//clientes.cpp define os métodos da classe clientes.
#include <iostream>
//#include"ciclone.h"
#include<string>
//#include"ocorrencias.h"
#include"clientes.h"// classe ocorrencias
//#include<iomanip>// setw(), setprecision()

using namespace std;


// --------construtor implícito ------------------------
clientes::clientes()
{    m_num_cliente=0;
	 m_nome_cliente=" ";
	 m_morada_cliente=" ";
     m_matricula=" ";
	 m_classe_veiculo= " ";
}

// --------construtor explícito ------------------------
clientes::clientes(int num_cliente, string nome_cliente, string morada_cliente, string matricula, string classe_veiculo )
{   
	 m_num_cliente=num_cliente;
	 m_nome_cliente= nome_cliente;
	 m_morada_cliente= morada_cliente;
     m_matricula= matricula;
	 m_classe_veiculo= classe_veiculo;
}

// --------método de leitura ----------------------------
void clientes::le(istream& entrada)
{ 
getline(entrada,m_nome_cliente);

getline(entrada,m_morada_cliente);

entrada >> m_num_cliente >> m_matricula >> m_classe_veiculo;

entrada.ignore(); // não lê a mudança de linha [\n]

entrada.ignore(); // não lê a linha em branco [\n
}

// --------método de escrita ---------------------------
void clientes::escreve(ostream& saida) const
{	
	saida<<m_nome_cliente<<endl;
	saida<<m_morada_cliente<<endl;
	saida<<m_num_cliente<<m_matricula<<m_classe_veiculo<<endl<<endl;
} 

// --------Acessores----------------------------------

string clientes::retornaNomeCliente() const
{ 
	return m_nome_cliente;
}

string clientes::retornaMoradaCliente() const
{ 
	return m_morada_cliente;
}

string clientes::retornaMatricula() const
{ 
	return m_matricula;
}
string clientes::retornaClasseVeiculo() const
{
	return m_classe_veiculo;
}

int clientes::retornaNumCliente()
{
	return m_num_cliente;
}

// --------operadores relacionais --------------------------------
/*bool clientes::operator==(const ocorrencias& operandoDireito) const
{
	return m_variavel == operandoDireito.retornaNumero();
}*/


Isto é a minha classe cliente !
 
JomarC disse:
Em C++ é possível reescrever código para operadores de modo a
manipularem operandos de classe diferente da que estão predefinidos

Esta característica confere uma maior legibilidade aos programas,
particularmente quando se trata de expressões aritméticas envolvendo
tipos definidos pelo programador

Métodos ou funções globais declaradas com a palavra chave operator
associado ao símbolo do operador:

operator @ ( )

promove a sobrecarga desse operador, sendo @ qualquer dos símbolos
susceptíveis de sobrecarga


by Acetatos do ISEP! lol

Exemplo:

Código: 
void Data::escreve(ostream & out) const
{ out << ano << "/" << mes << "/" << dia; }


ostream & operator << (ostream & out, const Data& d)
{ d.escreve(out) ;
return out ; }
Again acetatos ISEP! lol

Cumps
Clicar para expandir...


Tentei esse exemplo, ou pelo menos penso que tentem xD E nao resultou ! Eu e as classes não nos damos bem !

Vou continuar a tentar... Alguem sabe responder logo ao primeiro post que eu pus? : D
 
Em relação à primeira dúvida, não é possível fazeres o que queres. Só se guardasses isso num vector de strings :D O que podes fazer é ter uma classe onde guardas esses dados, e quando fores passar para o ficheiro fazes com esse formato. Do genero

Código: 
myfich << "[" << clientes[0].getNome() << "]";
acho que deu para perceber a ideia.

Em relação à segunda dúvida, podes fazer (e fica mais bonito) com overload do operator <<, tal como te disseram. provavelmente tens alguma coisa errada. Dentro da classe cliente (julgo ser esta...) fazes o overload tal como te disseram (não sei se é dentro ou fora da classe, mas tem mais logica ser dentro).

Código: 
ostream & operator << (ostream & os, const Cliente& c)
{ os << c.getNome() << " ---- " << c.getQQcoisa() << endl;
return os ; }
Outra maneira é definires um método publico, por exemplo void escreve() que quando chamado

Código: 
cout << vector_clientes[i].escreve() << endl;
apresenta a informação no ecra.
 
Última edição:
Inicie sessão ou registe-se para poder participar.
Back
Topo