[C++] definizione di una semplice classe

[Brazorv]

Devo fare un semplice esercizio di c++ che mi chiede di implementare la classe Complex.
ho fatto questi due file
complex.h

#ifndef COMPLEX_H
#define COMPLEX_H

class Complex{

    public:
        Complex(float=0.0, float=0.0);
        void setRe(float);
        float getRe();
        void setIm(float);
        float getIm();
        void print(); 
        
    private:
        float re;  // parte reale
        float im;  // parte immaginaria
}


#endif

e complex.cpp

#include <iostream>
#include "complex.h"

Complex::Complex(float r, float i){
    setRe(r);
    setIm(i);
}

void Complex::setRe(float r){
    re = r;
}

void Complex::setIm(float i){
    im = i;
}

float Complex::getRe(){
    return re;
}

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

void Complex::print(){
    std::cout << "(" << re << "," << im << ")" ;
}

quando complilo mi da il seguente errore

complex.cpp:4: error: new types may not be defined in a return type
complex.cpp:4: error: return type specification for constructor invalid

dove sbaglio?

[jappilas]

scusa ma c'è una cosa che non mi torna:
tu chiami funzioni membri della classe per implementare il costruttore...mentre se non sbaglio le funzioni Set e Get dovrebbero essere attive dopo che l' oggetto è stato istanziato, non prima... e infatti tutti i costruttori che ho visto erano della forma
dato1(a); dato2(b)... ; in questo caso re(r);im(i); ...

[Brazorv]

Originariamente inviato da jappilas

scusa ma c'è una cosa che non mi torna:
tu chiami funzioni membri della classe per implementare il costruttore...mentre se non sbaglio le funzioni Set e Get dovrebbero essere attive dopo che l' oggetto è stato istanziato, non prima... e infatti tutti i costruttori che ho visto erano della forma
dato1(a); dato2(b)... ; in questo caso re(r);im(i); ...

nel libro che sto usando, il Deitel, usa le set nel costruttore della classe, serve per non scrivere codice duplicato, perchè sia nel costruttore che nelle set si dovrebbero fare dei controlli sulla validità dei parametri.

cmq ho ricompilato senza usare le set nel costruttore e mi da lo stesso problema.

[cionci]

C'era una volta un punto e virgola.
Il punto e virgola si sentiva minacciato
dalla parentesi chiusa e decise quindi
di lasciare la sua posizione e di andare
a cercar fortuna per il mondo.

[Brazorv]

Originariamente inviato da cionci

C'era una volta un punto e virgola.
Il punto e virgola si sentiva minacciato
dalla parentesi chiusa e decise quindi
di lasciare la sua posizione e di andare
a cercar fortuna per il mondo.

penso che questo errore me lo ricorderò ogni volta che farò una nuova classe

[fek]

Originariamente inviato da Brazorv

penso che questo errore me lo ricorderò ogni volta che farò una nuova classe

E lo sbaglierai ogni volta come io lo sbaglio ogni volta da piu' di 10 anni a questa parte

[Brazorv]

Originariamente inviato da fek

E lo sbaglierai ogni volta come io lo sbaglio ogni volta da piu' di 10 anni a questa parte

sicuramente
ma almeno la prossima volta non rimarrò un'ora a capire casa ho sbagliato
spero

[anx721]

Originariamente inviato da fek

E lo sbaglierai ogni volta come io lo sbaglio ogni volta da piu' di 10 anni a questa parte

e non capisco a che diavolo serva poi quel punto e virgola oltre a farti sbagliare ogni volta...è un esempio di ridondanza sintattica veramente inutile...

[Brazorv]

Continuando l'esercizio ho scritto 2 metodi per fare la somma e la differenza

Complex Complex::add(const Complex *b) const{
    Complex res;
    res.setRe(re + b->getRe());
    res.setIm(im + b->getIm());
    return res;
}

Complex Complex::subtract(const Complex &b) const{
    Complex res;
    res.setRe(re - b.getRe());
    res.setIm(im - b.getIm());
    return res;
}

e vongono chiamati così

c=a.add(&b);
c=a.subtract(b);

secondo voi è meglio usare i puntatori come in add o i riferimenti come in subtract?

[cionci]

Originariamente inviato da anx721

e non capisco a che diavolo serva poi quel punto e virgola oltre a farti sbagliare ogni volta...è un esempio di ridondanza sintattica veramente inutile...

Non è vero... Quella oltra ad una dichiarazione può anche essere uno statement (anzi lo è)...per questo serve il ;

class a {
...
} pippo;

[cionci]

Originariamente inviato da Brazorv

Continuando l'esercizio ho scritto 2 metodi per fare la somma e la differenza
secondo voi è meglio usare i puntatori come in add o i riferimenti come in subtract?

Secondo te quale si capisce meglio
Se poi consideri che in questo caso dal puto di vista della traduzione in assembly sono esattamente equivalenti cosa preferisci ?

[jappilas]

non facevi prima a ridefinirti gli operatori?

[fek]

Originariamente inviato da Brazorv

Continuando l'esercizio ho scritto 2 metodi per fare la somma e la differenza

Complex Complex::add(const Complex *b) const{
    Complex res;
    res.setRe(re + b->getRe());
    res.setIm(im + b->getIm());
    return res;
}

Complex Complex::subtract(const Complex &b) const{
    Complex res;
    res.setRe(re - b.getRe());
    res.setIm(im - b.getIm());
    return res;
}

e vongono chiamati così

c=a.add(&b);
c=a.subtract(b);

secondo voi è meglio usare i puntatori come in add o i riferimenti come in subtract?

La consuetudine vuole che i parametri di ingresso si passino sempre con const&, mentre i parametri in uscita come puntatori.

[Brazorv]

Originariamente inviato da jappilas

non facevi prima a ridefinirti gli operatori?

sicuramente è il modo migliore ma ancora non ci sono arrivato

La consuetudine vuole che i parametri di ingresso si passino sempre con const&, mentre i parametri in uscita come puntatori.

allora è meglio così

Complex *Complex::subtract(const Complex &b) const{
    Complex *res;
    res->setRe(re - b.getRe());
    res->setIm(im - b.getIm());
    return res;
}

Grazie

[cionci]

Originariamente inviato da Brazorv

Complex *Complex::subtract(const Complex &b) const{
    Complex *res;
    res->setRe(re - b.getRe());
    res->setIm(im - b.getIm());
    return res;
}

Grazie

Questo codice è sbagliato...res non è allocato...e comunque non puoi ritornare un puntatore lì, a meno che tu non faccia un'allocazioen dinamica...

[Brazorv]

Originariamente inviato da cionci

Questo codice è sbagliato...res non è allocato...e comunque non puoi ritornare un puntatore lì, a meno che tu non faccia un'allocazioen dinamica...

si è vero non l'avevo provato
questo invece dovrebbe andare bene

Complex *Complex::subtract(const Complex &b) const{
    Complex *res =  new Complex();
    res->setRe(re - b.getRe());
    res->setIm(im - b.getIm());
    return res;
}

[jappilas]

Originariamente inviato da Brazorv

sicuramente è il modo migliore ma ancora non ci sono arrivato

è come per le funzioni ... in questo caso :

Complex operator+( Complex &altro );
Complex operator-( Complex &altro );

come membri pubblici della classe, e

Complex Complex::operator+( Complex & altro ){
return Complex( re + altro.re, im + altro.im );
};

Complex Complex::operator-( Complex & altro ){
return Complex( re - altro.re, im - altro.im );
};

come implementazione,
in questo caso effettivamente crea un nuovo oggetto Complex e lo ritorna

[jappilas]

Originariamente inviato da Brazorv

si è vero non l'avevo provato
questo invece dovrebbe andare bene

Complex *Complex::subtract(const Complex &b) const{
    Complex *res =  new Complex();
    res->setRe(re - b.getRe());
    res->setIm(im - b.getIm());
    return res;
}

uhm, crei un nuovo oggetto per usarne il puntatore, ma così mi pare resti allocato anche quando vai fuori scope
al che chiedo (perchè ho il dubbio, non è un dom retorica) : non è codice a rischio di leak?

stavo dando un' occhiata al criterio RAII, e mi pare la metodica sia differente...

[Brazorv]

Originariamente inviato da jappilas

uhm, crei un nuovo oggetto per usarne il puntatore, ma così mi pare resti allocato anche quando vai fuori scope
al che chiedo (perchè ho il dubbio, non è un dom retorica) : non è codice a rischio di leak?

ecco sono queste le cose che sto cercando di capire
però in effetti io volgio creare un nuovo oggetto che è il risulatato di una operazione fara altri 2.
Se metto un messaggio dentro il distruttore dell'oggetto riesco a capire quando viene distrutto?

[fek]

Originariamente inviato da Brazorv

si è vero non l'avevo provato
questo invece dovrebbe andare bene

Complex *Complex::subtract(const Complex &b) const{
    Complex *res =  new Complex();
    res->setRe(re - b.getRe());
    res->setIm(im - b.getIm());
    return res;
}

Questa implementazione viola un principio importante che va sempre tenuto a mente quando si programma in C++:
"Resource Acquisition Is Initalisation"

In italiano significa che chi crea un oggetto ne prende anche possesso ed e' il responsabile della sua distruzione. Se crei un oggetto Complex all'interno di un altro oggetto Complex dovresti anche mettere a disposizione i servizi per la sua distruzione.

Prova questa implementazione:

Complex& Complex::subtract(const Complex &b) const{
    setRe(re - b.getRe());
    setIm(im - b.getIm());
    return *this;
}

Se non vuoi che l'operazione modifichi l'oggetto, prova questa:

Complex& Complex::subtract(Complex* result, Complex const& a, Complex const& b) const
{
    result->setRe(a.getRe() - b.getRe());
    result->setIm(b.getIm() - b.getIm());
    return *res;
}

Questa versione segue la convenzione matematica di mettere il risultato come primo argomento. La convenzione in C++ lo vorrebbe pero' passato come ultimo argomento. Gusto personale qui.