[Código] Classe números complexos

[Henrique Barcelos 290]

Bom galera, to começando no mundo C++... Mas não é pq to começando que não tenho nada pra compartilhar http://forum.imasters.com.br/public/style_emoticons/default/assobiando.gif

 

Meu primeiro código foi esse aqui, onde faço a implementação para se trabalhar com números complexos, onde é possível se realizar todas as operações entre eles de modo "natural", através do overload dos operadores (menos divisão, esqueci como se faz, mas assim que conseguir achar e transformar num algoritmo eu edito o post http://forum.imasters.com.br/public/style_emoticons/default/thumbsup.gif)

 

#ifndef _COMPLEXOS_H
#define    _COMPLEXOS_H

using namespace std;
#include <iostream>
#include <cstdlib>
#include <string>
#include <math.h>

class complexo {
private:
    //propriedades
    float r, im;
public:
    //Construtores
    complexo(float _r, float _im);
    complexo();
    //Destrutur
    ~complexo();

    //Métodos
    void setReal(float real);
    void setIm(float imag);
    float getReal();
    float getIm();
    complexo conjugado();

    //Sobrecarga de Operadores Relacionais
    bool operator ==(complexo a);
    bool operator !=(complexo a);

    //Sobrecarga de Operadores Aritméticos
    complexo operator +(complexo a);
    complexo operator -(complexo a);
    complexo operator *(complexo a);
    complexo operator /(complexo a);

    //Sobrecarga de Operadores de Atribuição
    complexo & operator =(const complexo & a);
    complexo & operator +=(const complexo & a);
    complexo & operator -=(const complexo & a);
    complexo & operator *=(const complexo & a);
    complexo & operator /=(const complexo & a);

    //Sobrecarga de Operadores Unários
    complexo operator -() const;

    //Sobrecarga de Operadores IO
    friend istream & operator >>(istream &is, complexo &a);
    friend ostream & operator <<(ostream &os, complexo &a);
};

complexo::complexo(float _r, float _im) {
    r = _r;
    im = _im;
}

complexo::complexo() {
    r = 0;
    im = 0;
}

complexo::~complexo() {
}

void complexo::setReal(float real) {
    r = real;
}

float complexo::getReal() {
    return r;
}

void complexo::setIm(float imag) {
    im = imag;
}

float complexo::getIm() {
    return im;
}

complexo complexo::conjugado() {
    complexo conj(r, -im);
    return conj;
}

bool complexo::operator ==(complexo a) {
    return (r == a.r && im == a.im);
}

//Faço o overload da operação de desigualdade [!=]

bool complexo::operator !=(complexo a) {
    return (r != a.r || im != a.im);
}

//Faço o overload da operação de soma

complexo complexo::operator +(complexo a) {
    return complexo(r + a.r, im + a.im);
}

//Faço o overload da operação de subtração

complexo complexo::operator -(complexo a) {
    return complexo(r - a.r, im - a.im);
}

//Faço o overload da operação de multiplicação

complexo complexo::operator *(complexo a) {
    return complexo((r * a.r - im * a.im), (im * a.r + r * a.im));
}

complexo complexo::operator /(complexo a) {
    if (*this == a)
        return complexo(1, 0);
    else {
        float newR = (r * a.r + im * a.im) / (a.r * a.r - a.im * a.im);
        float newIm = (im * a.r - r * a.im) / (a.r * a.r - a.im * a.im);
        return complexo(newR, newIm);
    }
}

//Faço o overload da operação de igualdade [==]

/* Faço o overload das operação de atribuição [=],
 * autossoma [+=], autossubtração [-=], automultiplicação [*=]
 */

complexo & complexo::operator =(const complexo & a) {
    if (this != &a) {
        r = a.r;
        im = a.im;
    }
    return *this;
}

complexo & complexo::operator +=(const complexo & a) {
    r += a.r;
    im += a.im;
    return *this;
}

complexo & complexo::operator -=(const complexo & a) {
    r -= a.r;
    im -= a.im;
    return *this;
}

complexo & complexo::operator *=(const complexo & a) {
    //Faço a operação de multiplicação entre o proprio objeto e o objeto a
    *this = *this * a;
    return *this;
}

complexo & complexo::operator /=(const complexo & a) {
    /* Idem ao overload anterior
     */
    *this = *this / a;
    return *this;
}

//Faço o overloas da operação de troca de sinal [-]

complexo complexo::operator -() const {
    return complexo(-r, -im);
}

istream & operator >>(istream &is, complexo &a) {
    float r = 0, im = 0;
    cout << "Digite a parte real: ";
    cin >> r;
    cout << "Digite a parte imaginaria: ";
    cin >> im;

    a = complexo(r, im);
    return is;
}

ostream & operator <<(ostream &os, complexo &a) {
    /* Só vou mostrar a parte real se r != 0 OU se im == 0
     * Essa última condição é para o caso de r e im serem 0
     */
    if (a.r != 0 || a.im == 0)
        cout << a.r;

    if (a.im > 0)
        cout << "+";
    else if (a.im < 0)
        cout << "-";

    //Idem à parte real...
    if (a.im != 0) {
        /* com a diferença que quando im for 1,
         * tbm não mostro, já que 1+1i = 1+i*/
        if (fabs(a.im) != 1)
            cout << fabs(a.im);
        cout << "i";
    }
    cout << endl;
    return os;
}


#endif    /* _COMPLEXOS_H */

Dúvidas, críticas, sugestões... Postem!

 

P.S.: só não sei se vou saber responder às duvidas...

 

 

P.P.S: atualizei o post e agora também é possivel ler um número complexo com cin e escrever com cout http://forum.imasters.com.br/public/style_emoticons/default/thumbsup.gif

[VictorCacciari 42]

Muito bacana!

Apesar de ja existir uma classe, da STL que faz isso.

#include <complex>

 

sobre a divisão, é bem simples, vamos lá!

(a + b*i)
---------
(c + d*i)
## vou multiplicar pelo conjugado do denominador, tal como fazemos com raizes.
(a + b*i) * (c - d*i)
----------------------
     c² - d²

## Agora ja está tudo pronto... falta só simplificar a espressão
c*a + c*b*i - a*d*i - d*b*i²
---------------------------
     c² - d²

ca + cbi - adi + db
-------------------
     c² - d²                       c² - d² = K

ca + db      cb*i - ad*i
-------  +   -----------
  K               K

[Henrique Barcelos 290]

Opa, valeu aí Victor... http://forum.imasters.com.br/public/style_emoticons/default/graduated.gif

 

Professor de universidade eh td FDP msm... -.-', isso era um trabalho pra eu entrega... Tinha quase certeza que já tinha isso... massss...

 

Pois é, ontem à noite eu fui procurar em algum livro a divisão de complexos e achei...

 

Então estou atualizando o tópico...

[quitZAUMMM 18]

Muito legal seu código, fez na unha ;D

 

Os professores sempre fazem isso msm rs. em C++ você tem uma grande vantagem utilizando a STL.

 

[]s

 

---

Título Editado:

 

Classe números complexos http://forum.imasters.com.br/public/style_emoticons/default/seta.gif [Código] Classe números complexos