Newsgroup: it.comp.lang.c++
Titolo: Semplice problema su char

Ho creato una classe che rappresenta un numero complesso in forma letterale:
class Complex {
private:
            char re , im;
public:
            [...]
}
Il mio problema e' che non riesco a ridefinire l'operatore + per la mia
classe in modo che faccia la seguente operazione:
(a+jb) + (c+jd) = (a+c) + j(b+d)
Ovviamente il programma dovrebbe stampare l'output nella forma precedente.
Potete aiutarmi?
Grazie

 (a+jb) + (c+jd) = (a+c) + j(b+d)
Prima di tutto io userei degli int per memorizzare la parte reale ed
immaginaria. Poi aggiungerei un costrutture di questo tipo:
Complex(int re_, int im_): re(re_), im(im_) {};
A questo punto l'operator+ (che deve essere friend) e` banalmente:
const Complex operator+ (const Complex &a, const Complex &b) {
        return Complex(
a.re
 + 
b.re
, 
a.im
 + 
b.im
);
}
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
K.R.O.N.O.S
Kinetic Replicant Optimized for Nocturnal Observation and Sabotage

Ti ringrazio per l'interessamento, ma forse non mi sono spiegato bene. Il
problema e' questo: dati due numeri complessi C1=(a+jb) e C2=(c+jd) [a,b,c,d
non stanno ad indicare numeri, ma sono proprio lettere, per questo uso char!
In pratica sto cercando di costruire un programma che esegua calcoli
simbolici su numeri complessi!],  quando scrivo C3=C1+C2 vorrei che negli
slot di C3 fosse memorizzata come parte reale la stringa "a+c" e come parte
immaginaria la stringa "b+d". Infine quando stampo il contenuto di C3 voglio
che venga scritto esattamente nella forma: (a+c)+j(b+d). In termini piu'
semplici la domanda equivale a questa: date le variabili:
char ch1='a';
char ch2='b';
char * ch3;
come posso fare in modo che ch3 contenga la stringa "a+b"?
Grazie

non stanno ad indicare numeri, ma sono proprio lettere, per questo uso char!
[cut]
Come hai fatto non va bene, infatti se la parte immaginaria e quella
reale sono solo dei char potrai assegnargli al massimo un carattere
per volta. Devono almeno essere degli array di caratteri (di cui devi
però gestire l'allocazione) o meglio delle stringhe. Prova con il
primo esempio che ti ho proposto. Altrimenti guarda il secondo.
#include <string>
using namespace std;
string ch1="a";
string ch2="a";
string ch3;
ch3=ch1 + "+" + ch2;
oppure
sprintf(ch3, "%s+%s", ch1, ch2); 
/* devi stare attento alle dimensioni dell'area di memoria puntata da
ch3 */
Ciao.
Stefano
stsTO...@freemail.it
 (occhio all'antispam)

 ha scritto nel messaggio
news:ip00bugfqsmpatork...@4ax.com...



[cut]
Altro consiglio (idea folle).
Perchè non provi a definire una nuova classe su cui definisci le
operazioni in formato simbolico...es:
class symbolyc
{
	private:
		string s;
	public:
		symbolic();
		~symbolic();
		const string str(void) {return s;};
		symbolic operator+(const symbolic& a);
};
symbolic symbolic::operator+(const symbolic& a)
{
	symbolic sum;
	sum=s+a.str;	
}
se hai voglia puoi fare in modo che se la somma è 'a'+'a' il risultato
sia 2*a, lo stesso vale per il prodotto.
Fatto questo basta fare
#include "symbolic.h"
#include <complex.h>
int main(void)
{
	complex<symbolic> a,b;
	cout << a+b;
 
	return 0;
}
buon divertimento.
Stefano
stsTO...@freemail.it
 (occhio all'antispam)
P.S.: occhio al quoting.

 P.S.: occhio al quoting.
Sorry! Ciao e grazie ancora!

 #include <complex.h>
Se con questo intendi l'header standard <complex>, tieni presente che
non e' garantito il funzionamento corretto di std::complex se
specializzato su un tipo diverso dai tipi floating point nativi.
La strada originaria mi pare vantaggiosa:
class Complex {
  public:
    Complex(std::string re_,std::string im_) : re(re_), im(im_) {}
    //....
    friend Complex & operator+ (const Complex & c1, const Complex & c2)
{
      return Complex(
c1.re
 + "+" + 
c2.re
,
c1.im
 + "+" + 
c2.im
);
    }
  private:
    std::string re;
    std::string im;
};
Quello che certamente vale la pena di considerare e' l'eventualita' di
utilizzare specializzazioni per rappresentare casi particolari, tipo
ComplexLiteral, ComplexExpression e via dicendo. A naso queste diventano
indispensabili aggiungendo nuovi operatori, perche' presto diventa
necessario prevedere l'uso di parentesi.
L' OP puo' trarre ispirazione dall'interprete di espressioni aritmetiche
che B. Stroustrup usa come esempio nei primi capitoli di "The C++
Programming Language".
Ciao,
Nicola

 simbolici su numeri complessi!],  
quel che chiedi non e` proprio cosi` semplice. IMHO dovresti partire per 
gradi:
1) creare una classe Variabile con lo scheletro simile a questo:
class Variabile {
        char lettera;
        int grado;
public:
        ....
};
Il concetto di alto livello incapsulato da questa classe e` un qualcosa 
del tipo "x", "y^2", ecc.
2) creare una classe Monomio: in pratica e` una sequenza di Variabili 
moltiplicate tra di loro:
class Monomio {
        std::vector<Variabile> x;
public:
        ...
};
3) creare una classe Polinomio che rappresenta una somma di piu` Monomi:
class Polinomio {
        std::vector<Monomio> x;
public:
        ...
};
A questo punto puoi realizzare la tua Complex basandoti su Polinomio:
class Complex {
        Polinomio real;
        Polinomio im;
public:
        ...
};
Ovviamente per ogni classe della tua applicazione devi anche definire le 
oppurtune operazioni, come ad es:
        Monomio * Monomio --> Monomio
        Monomio + Monomio --> Polinomio
        Polinomio + Polinomio --> Polinomio
        Polinomio * Polinomio --> Polinomio
Nota che dovresti anche gestire operazioni del tipo 
        Monomio + Polinomio
        Monomio * Polinomio
ma il mio consiglio in questo caso e` di fornire una conversione 
implicita Monomio --> Polinomio in quando un Monomio e`, a tutti gli 
effetti, un Polinomio con un solo termine.
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.73, higher than 99% of all previous test takers.
C Language: 3.79, higher than 92% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it