Castro

:rolleyes: A citação tenta explicar o uso de classe no código abaixo, mas acho que está confuso: Programa: class Nome_classe { private: double v; public: Nome_classe(double a) {v=a; } double visivel() {return v;} }; ostream &operator<<(ostream &out, Nome_classe obj) { out << obj.visivel(); return out; } int main() { Nome_classe exemplo(2.6); cout << "Saida da funcao que sobrecarrega <<" << endl << endl; cout << exemplo << endl; } Saída do programa: 1-O objetivo da citação acima, é explicar o uso da classe na função: Usada no código, também acima, só que não entendi bem a explicação que foi tirada da internet(citação) tem como explicar este texto? 2- Na classe temos: Nome_classe(double a) {v=a; } double visivel() {return v;} Qual o papel do construtor neste programa, se é a função visivel(), que dá visibilidade para variável v na função que sobrecarrega o operador << ? Obrigado

:wacko: Considere o fragmento de código #include <iostream> #include <cstdlib> using namespace std; class Sobrecarga { private: double x,y,saida_tela; public: //Construtor Sobrecarga(double valor); //Operadores unários Sobrecarrega& operator++(); //pré-incremento Sobrecarrega& operator++(int); //pós-incremento Sobrecarrega& operator--(); //pré-decremento Sobrecarrega& operator--(int);//pós-decremento //Operador binnario Sobrecarrega operator+(Sobrecarrega s1);//adição Sobrecarrega operator-(Sobrecarrega s2); //função amiga para imprimir o valor de "a" friend ostream& operator<<(ostream& os, Sobrecarrega obj); }; Sobrecarga Sobrecarrega::operator-(Sobrecarrega s2) { Sobrecarga sub(0.0); sub.x= x - s2.x; sub.y= y - s2.y; sub.saida_tela = saida_tela - s2.saida_tela; return sub; } int main() { Sobrecarga a(4.0); cout << "Saida original de \"a\"." << endl; cout << a << endl; cout << "Saidal de \"a++\"." << endl; a++; cout << a << endl; return(0) } Por que o nome da função em sobrecarga de operadores tem de ser o mesmo nome da classe para o programa compilar? O código acima não pode ser compilado. Entretanto se eu fizer: #include <iostream> #include <cstdlib> using namespace std; class Sobrecarga { private: double x,y,saida_tela; public: //Construtor Sobrecarga(double valor); //Operadores unários Sobrecarga& operator++(); //pré-incremento Sobrecarga& operator++(int); //pós-incremento Sobrecarga& operator--(); //pré-decremento Sobrecarga& operator--(int);//pós-decremento //Operador binnario Sobrecarga operator+(Sobrecarga s1);//adição Sobrecarga operator-(Sobrecarga s2); //função amiga para imprimir o valor de "a" friend ostream& operator<<(ostream& os, Sobrecarga obj); }; Sobrecarga Sobrecarga::operator-(Sobrecarga s2) { Sobrecarga sub(0.0); sub.x= x - s2.x; sub.y= y - s2.y; sub.saida_tela = saida_tela - s2.saida_tela; return sub; } int main() { Sobrecarga a(4.0); cout << "Saida original de \"a\"." << endl; cout << a << endl; cout << "Saidal de \"a++\"." << endl; a++; cout << a << endl; return(0) } Se eu escrever o programa desta forma, irá compilar corretamente. Poderiam explicar a diferença entre uma forma e outra? as funções de sobrecarga ou protótipo das funções de sobrecarga, não tem tipo de retorno como em: double minha_ função( int v); poderiam explicar? Obrigado

:wacko: Vejam o código: class Sobrecarga { private: double x,y,saida_tela; public: //Construtor Sobrecarga(double valor); //Operadores unários //Sobrecarga& operator++(int); Sobrecarga& operator++(); Sobrecarga& operator--(int); Sobrecarga& operator--(); //Operador binnario Sobrecarga operator+(Sobrecarga s1); //função amiga para imprimir o valor de "a" friend ostream& operator<<(ostream& os, Sobrecarga obj); }; Sobrecarga::Sobrecarga(double valor) { saida_tela=valor; x = valor; y = valor; } Sobrecarga& Sobrecarga::operator++() { this->x++; this->y++; this->saida_tela++; return *this; } /*Sobrecarga& Sobrecarga::operator++(int) { this->x++; this->y++; this->saida_tela++; return *this; } */ ostream &operator<<(ostream& os, Sobrecarga obj) { //os << obj.x; //os << obj.y; os << obj.saida_tela; return os; } int main() { Sobrecarga a(4.0); cout << "Saida original de \"a\"." << endl; cout << a << endl; cout << "Saidal de \"a++\"." << endl; a++; cout << a << endl; return 0; } Erro: Se eu destravar a função que faz o incremento com argumento int o erro desaparece. Por que uma parece estar dependendo da outra? Se eu fizer o mesmo com a função que sobrecarrega o operador de decremento, o erro é o mesmo. Obrigado

:( Vejam o erro de compilação do programa. Estou tentando sobrecarregar o operador + #include <iostream> #include <cstdlib> using namespace std; class Sobrecarga { private: double x,y,n,temp; public: Sobrecarga(double num); //Operadores unários Sobrecarga& operator++(int); Sobrecarga& operator++(); Sobrecarga& operator--(int); Sobrecarga& operator--(); //Operador binnario Sobrecarga& operator+(Sobrecarga s1); }; Sobrecarga::Sobrecarga(double num) { n = num; } Sobrecarga& Sobrecarga::operator+(Sobrecarga s1) { Sobrecarga temp; temp.x= x + s1.x; temp.y= y + s1.y; return temp; } int main() { cout << "sobrecarga de operadores " << endl; Sobrecarga a(6.0); a++; return 0; } As linhas marcadas como erradas pelo compilador são: Sobrecarga::Sobrecarga(double num) E Sobrecarga temp; Erros: Obrigado

:( O programa abaixo apresentou erro de compilação após eu inserir um construtor. Vejam: #include <iostream> #include <cstdlib> using namespace std; class Sobrecarga { private: double x,y,n; public: Sobrecarga(double num){n = num;}; //Operadores unários Sobrecarga operator++(int); Sobrecarga operator++(); Sobrecarga operator--(int); Sobrecarga operator--(); //Operador binnario Sobrecarga operator+(Sobrecarga s1); }; Sobrecarga Sobrecarga::operator++() { this->x++; this->y++; return *this; } Sobrecarga Sobrecarga::operator++(int) { this->x++; this->y++; return *this; } Sobrecarga Sobrecarga::operator--(int) { this->x--; this->y--; return *this; } Sobrecarga Sobrecarga::operator--() { this->x--; this->y--; return *this; } Sobrecarga Sobrecarga::operator+(Sobrecarga s1) { Sobrecarga temp; temp.x=x + s1.x; temp.y=y + s1.y; return temp; } int main() { cout << "sobrecarga de operadores " << endl; Sobrecarga a(6); a++; return 0; } Erros: Obrigado

:( Veja o programa. Como sobrecarregar cin e cout? #include <iostream> #include <cstdlib> using namespace std; class Mostra { double v; public: Mostra (double a) {v=a;} }; int main() { Mostra a(2.6); cout << a; system ("pause"); return 0; } ostream& operator<< (ostream& out, Mostra& valor) { out << "Mostra:" << valor.v << endl; return out; } Quando mando compilar o programa, a IDE congela. Se eu faço: cout << v; Recebo a seguinte menssagem de erro: Por "v" não ser declarada em main(). Que fazer ? Obrigado

:( Estou querendo sobrecarregar o operador de adição como se fosse ++. Nos livros do DEITEL e Herbert Schildt as explicações sobre o tema são horríveis. Indicaram-me material da internet no link http://www.dimap.ufrn.br/~adilson/DI...Operadores.PDF, mas achei os exeplos complexos e didática ruim. Juntando todos meus esforços, comsegui escrever este código falho, e que não consegue atingir o objetivo. Foi-me dito, que numa sobrecarga, é preciso envolver pelo menos dois objetos. Tipo: Objeto1 + Objeto2. Não consigo vislumbrar o código que satisfaça meu objetivo. Poderiam corrigir meu código para que ele funcione como quero. Assim poderei iniciar discussão sobre o tema, e ter um exemplo simples. Um exemplo simples é tudo que preciso para começar a entender o tema. Por isso se puderem acertar meu código fico grato. #include <iostream> #include <cstdlib> using namespace std; class sobrecargaAD { private: double x; public: sobrecargaAD operator+(sobrecargaAD ad); }; sobrecargaAD sobrecargaAD::operator+(sobrecargaAD ad) { sobrecargaAD incrent; increment.x++; } int main() { cout << "sobrecarga do operador + para ++" << endl; sobrecargaAD incr (2): return 0; } Obrigado

:( Poderim me indicar uma IDE para ser usada com o MingW ? baixei, atualizei e instalei o MingW, mas preciso de uma IDE para facicitar o uso. Já tentei o codeblocks versão 23MB e a versão 75 MB- completa. Tanto uma como na outra não foi possível reconhecer o GCC GNU; por isso estou pedindo para indicar uma IDE que não o code Blocks. Obrigado

:( Alguém poderia me indicar links de videos-aula sobre sobrecarga de operadores em C++ ? fui no google, mas é aquilo ... você acha que é uma coisa e é outra. Obrigado

:( Mudei o programa para: #include <iostream> using namespace std; class Circulo { private: double Area,raio; static const double PI; double Area_Circulo(); public: Circulo (double r); void Mostra_Area(); double Pega_raio (); // para pegar o valor do raio e //permitir acesso da classe derivada }; class Medidas_Circunferencia : public Circulo { private: double Diametro; double Diametro_Circunferencia(); public: Medidas_Circunferencia(double r):Circulo (r){}; void Mostra_Medidas_Circunferencia(); }; Circulo::Circulo(double r) :Area(0) { raio=r; } double Circulo::Pega_raio () { return (raio); } double Circulo::Area_Circulo() { cout << "Area area do Circulo." << endl; Area=(raio*raio)*PI; // Área do Circulo return (Area); } void Circulo::Mostra_Area() { Area_Circulo(); cout << Area << endl; return; } double Medidas_Circunferencia::Diametro_Circunferencia() { Pega_raio(); //passa cout << "Diametro da circunferencia:" << endl; Diametro=2*raio; return(Diametro); } void Medidas_Circunferencia::Mostra_Medidas_Circunferencia() { Diametro_Circunferencia(); return; } const double Circulo::PI=3.1416; //define a variável no //escopo global int main() { Medidas_Circunferencia Medidas(15); Medidas.Mostra_Area(); cout << endl; system ("pause"); return 0; } Se os parâmetros-padrão de uma função membro tem de ser constantes (eu não sabia disso), então fiz: double Circulo::Pega_raio () { return (raio); } busquei fazer de Pega_raio () apenas uma função de acesso para retornar raio, visando seu uso na derivada. Também tirei o acento colocado indevidamente. Mesmo assim ocorreram os seguintes erros: Resolvida esta questão, corrigirei a concepção matemática. Obrigado

:( Vejam o código: #include <iostream> using namespace std; class Circulo { private: double Area,raio; static const double PI; double Area_Circulo(); public: Circulo (double r); void Mostra_Area(); }; class Medidas_Circunferencia : public Circulo { private: double Diametro; double Diametro_Circunferencia(); public: Medidas_Circunferencia(double r):Circulo (r){}; void Mostra_Medidas_Circunferencia(); }; Circulo::Circulo(double r) :Area(0) { raio=r; } void Circulo::Mostra_Area() { Area_Circulo(); cout << Area << endl; return; } double Medidas_Circunferencia::Diametro_Circunferencia() { cout << "Diametro da circunferência:" << endl; Diametro=2*raio; return(Diametro); } void Medidas_Circunferência::Mostra_Medidas_Circunferencia() { Diametro_Circunferencia(); return; } ........... ............. const double Circulo::PI=3.1416; int main() { Medidas_Circunferencia Medidas(15); Medidas.Mostra_Area(); cout << endl; return 0; } Na linha abaixo estou chamando o construtor da classe-Base Circulo, junto do construtor da derivada, pois sei que construtores não padrão da classe base, tem de ser chamados na derivada. Medidas_Circunferencia(double r):Circulo (r){}; Sendo o construtor publico, não deveria dar acesso aos membros privados da classe base ? preciso usar PI e raio para calcular diâmetro na derivada. Construtor a parte, ainda criei uma função publica para chamar a função que calcula o dímetro. Não deveria funcionar pelo menos por causa da função pública ? Erros: Obrigado

:( Se não me engano, o exemplo que você deu é do livro do Deitel, acertei ? O livro é bom, mas os exemplos dele neste tema, são complexos. O livro do Hebert Schildt - C++ guia para iniciantes - neste tema não dá nem para começar o entendimento. Consegui este exemplo, mas está dando alguns problemas #include <iostream> using namespace std; class MinhaString {public: //MinhaString ( ) { } MinhaString (const char* s = ""); ~MinhaString ( ); const char* getString ( ); // Sobre carga de operadores void operator = (const char* s); bool operator == (const MinhaString s); private: void setString ( const char* s ); private: int tamanho; char* pStr; }; void MinhaString::setString ( const char* s ) { pStr = new char [ tamanho + 1 ]; strcpy ( pStr, s ); } const char* MinhaString::getString ( ) { return pStr; } void MinhaString::operator = (const char* s) { //. . . } bool MinhaString::operator == (const MinhaString s ) { char* aux = new char [ strlen (s.getString()) + 1 ]; strcpy ( aux, s.getString() ); // if ( 0 == strcmp ( sPtr, s.getString () ) ) if ( 0 == strcmp ( pStr, aux ) ) { return true; } else { return false; } } int main() { } Poderiam consertar ? não sei o que fazer ? Erros: Obrigado

:D Ok. Resolvi o problema do retorno do valor da multiplicação. Assim sendo, gostaria de voltar ao tema. Considere as linhas: var1 e var2 são parâmetros definidos em; int Multiplicar(Multiplica_amiga& var1,Multiplica_amiga& var2) então qual a lógica de var1 e var2 nas linhas abaixo ? não parece redundante ? é a primeira vez que vejo nome de parâmetro ser o mesmo de argumento. Multiplica_amiga var1, var2; Multiplicar(var1,var2); Poderia ajudar no link abaixo ? http://scriptbrasil.com.br/forum/index.php?showtopic=161426 livros como do Deitel e Hebert Schildt não são didáticos no tema do link Obrigado

:( Estou precisando de exemplos, o mais simples possível,dos seguintes itens: 1-sobrecarga de operadores inserção e extração de fluxo; 2-Sobrecarga de operador unario; 3-Sobrecarga de operador binário. Um exemplo de cada e funcionais. Pesquisei na Internet, mas só achei material jogado e complicados. Pode ser com função amiga, quando aplicavel Obrigado

:D Deu certo !!! Agora que deu certo, gostaria de tirar algumas dúvidas sobre a sintaxe: friend int Multiplicar(Multiplica_amiga& var1, Multiplica_amiga& var2); int Multiplicar(Multiplica_amiga& var1,Multiplica_amiga& var2) { . . return (produto) } Nas linhas acima, o nome da classe foi passado com símbolo de rereferência -&- por quê ? int main() { Multiplica_amiga var1, var2; Multiplicar(var1,var2); return(0); } por que não precisei indicar o tipo para var1 e var2 ? Por fim veja a classe e as funções class Multiplica_amiga { friend int Multiplicar(Multiplica_amiga& var1, Multiplica_amiga& var2); private: int valorA,valorB,recebe_produto; public: Multiplica_amiga():valorA(2),valorB(5) { recebe_produto=produto; } void Mostra_produto(); }; int Multiplicar(Multiplica_amiga& var1,Multiplica_amiga& var2) { int produto; produto = var1.valorA * var2.valorB; return (produto); } void Multiplica_amiga:: Mostra_produto() { cout << recebe_produto << endl; return; } por que não consigo retornar a variável produto para a varíavel recebe_produto no construtor ? mesmo que eu deixe de declarar produto como local da função e declare como atributo de classe, ainda sim recemo mensagem dizendo que produto não foi declarado. Obridado

:wacko: Quando disse para passar objeto, entendi que era para passar o nome da classe(no caso com membros usados) como argumento. Tentei as seguintes Variações: int main() { //Multiplica_amiga Multiplicar; Multiplica_amiga var1, var2; Multiplicar(Multiplica_amiga); return(0); } Erro: Tentei: int main() { Multiplicar(Multiplica_amiga); return(0); } Erro Tentei int main() { Multiplicar(Multiplica_amiga&()); return(0); } Erro: Tentei int main() { Multiplicar(Multiplica_amiga()); return(0); } Erro: Por fim tentei int main() { Multiplicar(Multiplica_amiga& var1,Multiplica_amiga& var2); return(0); } Logicamente mais erro. Se eu fizer: int main() { //Multiplicar(Multiplica_amiga); return(0); } travando a linha o programa compila. Ainda enxerguei meu erro.

:( Quando fui chamar a função no programa principal, seguindo seu modelo, o ocorreu erro, pois a função não reconheceu as variáveis valorA e ValorB. #include <iostream> using namespace std; class Multiplica_amiga { friend int Multiplicar(Multiplica_amiga& var1, Multiplica_amiga& var2); private: int valorA,valorB; public: Multiplica_amiga():valorA(2),valorB(5) { } }; int main() { [b]Multiplicar(valorA,valorB);[/b] return(0); } int Multiplicar(Multiplica_amiga& var1,Multiplica_amiga& var2) { int produto; produto = var1.valorA * var2.valorB; return (produto); } Ao inicializar valorA e valorB no construtor, imaginei que estas tivessem visibilidade na chamada da função, no programa principal. Onde ainda estou errando ? Erros: Obrigado Ps: a confirmação de menagem não está chemando na minha caixa de e-mail.

:( #include <iostream> using namespace std; class Multiplica_amiga { friend int Multiplicar(Multiplica_amiga,int &var1, int&var2); private: int valorA,valorB; public: Multiplica_amiga():valorA(2),valorB(5) { } void Mostra_produto(); }; int main() { return(0); } int Multiplicar(Multiplica_amiga, int &var1, int &var2) { int produto; produto = var1.valorA * var2.valorB; return (produto); } Erros: Observe, que ainda existe reclamação quanto ao uso da referência, e a função não enxerga o as variáveis inicializadas pelo construtor. Onde erro ? Obrigado

:wacko: Nova versão Construtor retornando lixo: class Efetua_calculo { private: double total; double valores_entrada[4]; double devolve_valores_entrada[4]; char texto[50]; double soma(); double divide(); public: double Entrada_valores(void); void Saida_calculo(void); Efetua_calculo(double recebe[]); }; Efetua_calculo::Efetua_calculo(double recebe[]) { total=0; strcpy(texto,"Resultado das funcoes soma() e divide() e:"); recebe[0]=valores_entrada[0]; recebe[1]=valores_entrada[1]; recebe[2]=valores_entrada[2]; recebe[3]=valores_entrada[3]; devolve_valores_entrada[0]=recebe[0]; devolve_valores_entrada[1]=recebe[1]; devolve_valores_entrada[2]=recebe[2]; devolve_valores_entrada[3]=recebe[3]; } double Efetua_calculo::Entrada_valores (void) { int i=0; cout << "Entre com os valores das funções soma e divide." << endl; while (i<4) { cin >> valores_entrada[i]; i++; }; return (*valores_entrada); } void Efetua_calculo::Saida_calculo (void) { cout << texto << endl; cout << soma() << endl; cout << divide() << endl; cout << "valores retornados do construtor: " <<endl; cout << devolve_valores_entrada[0] << endl; cout << devolve_valores_entrada[1] << endl; cout << devolve_valores_entrada[2] << endl; cout << devolve_valores_entrada[3] << endl; return; } int main () { double inicializa[4]={0.0,0.0,0.0,0.0}; //instancia a classe Efetua_calculo calculo(inicializa); calculo.Entrada_valores(); calculo.Saida_calculo(); return (0); } saída: Obrigado

:wacko: A idéia básica é passar para parâmetros de um construtor, valores inseridos numa função de entrada de dados. Estes valores devem ser devolvidos pela função via retorno de um vetor. Os valores do vetor devem ser recebidos pelos parâmetros do construtor. class Efetua_calculo { private: double total; char texto[50]; double soma(); double divide(); double Entra_valores (double *valorvet); public: void Mostra_calculo(); Efetua_calculo (double valora,double valorb,double valorc, double valord) { Entra_valores(); valora=valorvet[0]; valorb=valorvet[1]; valorc=valorvet[2]; valord=valorvet[3]; total=0; strcpy(texto,"Resultado das funcoes soma() e divide() e:"); } }; double Efetua_calculo::Entra_valores (double *valorvet) { double vet[4]; int i=0; cout << "Entre com os valores das funções soma e divide." << endl; do { cin >> vet[i]; i++; } while (i<4); for (i=0; i <4; i++) { valorvet[i]=vet[i]; } return (*valorvet); } void Efetua_calculo::Mostra_calculo (void) { cout << texto << endl; cout << soma() << endl; cout << divide() << endl; return; } int main () { Efetua_calculo calculo(); calculo.Mostra_calculo(); return 0; } Erros: Onde estou errando ? Obrigado

:rolleyes: Ok. Obrigado, mas poderia comentar a linha: cout << "Mostre o valor de *&ipr & e * (se anulam): " << *&ipr << end; Li que usar *& se anulam e mostram o mesmo valor de ipr. O que isto quer dizer ? de quem é o valor mostrado, realmente, na linha acima ? Obrigado

:mellow: Ok. Entendi. Funciona da mesma forma como não se fosse vetor. Considere o seguinte fragmento de código: int *p; int var; p=&var; p++; No fragmento de código, a linha p++ faz um incremento na posição de memória, ou seja faz uma aritmética de ponteiros. Li que esta opração só faz sentido se for feita com array, pois há uma posição consecultiva na memória. No exemplo acima isso não acontece. Temos apenas um endereço de memória que sofre um incremento. Segundo alguns autores, fazer este incremento seria errado, pois não se sabe para que região de memória vai ser apontada. Poderiam comentar ? isso procede ? se isso é verdade, por que alguns livro dão exemplos como estes ? Obrigado

:rolleyes: Considere a declarção: int vet[5]; int *v; v=vet; Se eu fizer: cout << v << end; verei um endereço de memória. se eu fizer: cout << &v << end; verei um endereço de memória diferente. Em se tratando de arrays, qual a diferença nestes dois casos ? o que etá sendo mostrado em um caso e outro ? Obrigado

:mellow: Encontrei um programa chamado "Free Download Manager". Ele é bem mais leve que o jdownloader. Diz que acelera bem o download do arquivo de vídeo, além de continuar apoós interrupção. Baixa o arquivo no formato flv. Ah !! está em português. Na hora de instalar ele pede para você informar o tipo de conexão para facilitar o desempenho do programa. Por falar nisso alguém sabe o que é modem ISDN ? alguém tem experiência com este programa. Pelo que pude perceber, ao informar a URL, o programa já exige que o formato do arquivo esteja em flv. Se não tiver ele não baixa. Ele não faz conversão de formato, isso diminui opções de download. Jdownloadader parece o melhor, mas é muito pesado para quem não tem banda larga. Estou testando o atube Catcher eleve, mas não mantém o download do ponto que parou após uma interrupção. Conhecem algum outro programa que faça download de vídeo que continue após o download ser interrompido, gratuito e que seja leve ? Obrigado

:wacko: Considere o código: #include <iostream> using namespace std; int main() { int *ipr, i=10; double *vpr,v=5.2;; ipr=&i; vpr=&v; cout << "Mostre o valor de i : " << i << endl; cout << "Entre com novo valor de i via *ipr: "; cin >> *ipr; cout << "Mostre o novo valor de i : " << i << endl; cout << "Mostre o valor de ipr : " << ipr << endl; cout << "Mostre o valor de *&ipr & e * (se anulam): " << *&ipr << endl; cout << "Mostre o valor de &vpr : " << &ipr << endl; cout << endl; system ("pause"); return 0; } 1- Se &ipr mostra um endereço em hexadecimal, o que representa o valor hexadecimal mostrado por ipr ? lixo ? 2- Como a própria linha diz: cout << "Mostre o valor de *&ipr & e * (se anulam): " << *&ipr << end; se anulam e mostram o mesmo valor de ipr. O que isto quer dizer ? Obrigado