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