[ azzpoz @ 24.11.2013. 15:16 ] @
Code:

class NizInt
{
   int *niz;
   int trenutno; //brojac trenutne pozicije u nizu;
   int max;

//....
}


Code:
NizInt NizInt::operator+( NizInt &desni)
{     
      
      int tmp[10];
      for(int i=0;i<10;i++)
              tmp[i] = niz[i];
      int tmp_trenutno = trenutno;
      
       delete []niz;
       
       niz = new int[desni.max];
       trenutno = desni.trenutno;
       max = desni.max;
       for(int i=0;i<tmp_trenutno;i++)
         niz[i] = tmp[i]; 
       for(int i=tmp_trenutno;i<tmp_trenutno+trenutno;i++)
               niz[i] = desni.niz[i-tmp_trenutno];
       
       return *this;
}


Više oblika operatora+ sam uradio, ali niti jedan nije ispravan...

Želio bih dodati na već postojeći niz još, a da pri tome ne promijenim objekat koji poziva operator+!!!

Npr. obj = A + B + C;
>> B ce promijeniti izvorni oblik, ovo ne zelim
>> A ce promijeniti izvorni obli, ovo ne zelim

>> obj treba biti suma, sto je ok
[ Burgos @ 24.11.2013. 15:29 ] @
Samo kreiraj novi objekat unutar njega.

Code:
NizInt NizInt::operator+( NizInt &desni)
{     
      NizInt ret_obj;

      int tmp[10];
      for(int i=0;i<10;i++)
              tmp[i] = niz[i];
      int tmp_trenutno = trenutno;
      
       delete ret_obj.niz;
       ret_obj.niz = new int[desni.max];
       ret_obj.trenutno = desni.trenutno;
       ret_obj.max = desni.max;

       for(int i=0;i<tmp_trenutno;i++)
            ret_obj.niz[i] = tmp[i]; 

       for(int i=tmp_trenutno;i<tmp_trenutno+ret_obj.trenutno;i++)
               ret_obj.niz[i] = desni.niz[i-tmp_trenutno];
       
       return  ret_obj;
}


Sada, naravno, ovo treba lepo napisati, ali je ideja kljucna.
[ azzpoz @ 24.11.2013. 15:58 ] @
Šta je s memorijom koju zauzimamo kreirajući pomoćne objekte?!

Da li se oni tek brišu prilikom završavanja programa?!
Interesuje me ideja vaša, na koji način bi mogao poboljšati program na način da pomoćne objekte izbrišem nakon završene operacije i sl.
[ Burgos @ 24.11.2013. 16:09 ] @
Ako imaš:


Code:
NizInt a, b;
NizInt c = a + b;


a + b će se izračunati, vratiće se privremeni objekat, izvršiće se konstruktor kopije, inicijalizovaće se c i privremeni objekat će se uništiti. Kompajler je čak dovoljno pametan, pa u ovom slučaju se može izbeći kopiranje, tako što će se tmp inicijalizovati na mesto memorije objekta c.




Naravno, druga stvar je ovo:


Code:

NizInt* NizInt::operator+( NizInt &desni)
{     
      // loše rešenje
      NizInt ret_obj = new NizInt(); // ovaj objekat se briše ili eksplicitnim delete, ili na kraju memorije
      // ...
      return ret_obj;
}


Opet, za prvi slučaj: Obrati pažnju da povratni tip funkcije ne bude referenca - svi objekti alocirani na steku će prestati da postoje pri izlasku iz funkcije (ili bloka) - dakle, pogrešno je vratiti referencu - vraćaj objekat po vrednosti.
[ azzpoz @ 24.11.2013. 16:18 ] @
Zar nije:
Kada referencu koristimo, objekti postoje u funkciji i van funkcije?!

Zbog cega mi javlja gresku kada zelim koristi =

Code:
#include <iostream>
using namespace std;

class mojstring
{
      char *ime;
      
      public:
             
             mojstring(char *i = "1234")
             {
                            ime = new char[strlen(i)+1];
                            strcpy(ime, i);
             }
             ~mojstring()
             {
                         delete []ime;
                         ime = NULL;
             }
             mojstring &operator=(mojstring &i)
             {
                       delete []ime;
                       
                       ime = new char[strlen(i.ime)+1];
                       strcpy(ime, i.ime);
                       
                       return *this;
             }
             mojstring operator+(mojstring &desni)
             {
                       char tmp[100];
                       strcpy(tmp, this->ime);
                       strcat(tmp, desni.ime);
                       mojstring Povratni(tmp);
                       
                       return Povratni;
             }
             friend ostream &operator<<(ostream &, mojstring &);
             
};
ostream &operator<<(ostream &OUT, mojstring &org)
             {
                     OUT << org.ime << " ";
                     
                     return OUT;
             }
int main()

{
    
    mojstring A("Vejz");
    mojstring B("Nop");
    
    mojstring C(A+B);
    
    cout << A << B << C <<endl;
    
    C = A + B;
    
    cout << A << B << C << endl;
    
    system("pause>0"); return 0;
}



[Ovu poruku je menjao azzpoz dana 24.11.2013. u 17:28 GMT+1]
[ gospodin.kojot @ 24.11.2013. 17:19 ] @
Napravi copy konstruktor
[ azzpoz @ 24.11.2013. 17:25 ] @
Zašto COPY konstruktor kada sam već inicijalizovano/kreirao objekat?!

Želim mu naknadno dodijeliti vrijednosti preko operatora =
[ azzpoz @ 24.11.2013. 17:26 ] @
Citat:
gospodin.kojot:
Napravi copy konstruktor


Uspio sam riješiti problem, tako što sam dodao const u:
mojstring &operator=(mojstring &i)


[Ovu poruku je menjao azzpoz dana 24.11.2013. u 18:52 GMT+1]
[ Burgos @ 24.11.2013. 18:03 ] @
Da, taj problem si imao i pre neki dan - ako hoćeš da prihvatiš privremeni objekat - povratnu vrednost, moraš to uraditi kroz metodu koja prima referencu na njega kao const.

Citat:
Kada referencu koristimo, objekti postoje u funkciji i van funkcije?!


Ne znam na šta misliš - verovatno na to da više referenci može da pokazuje na jedan objekat. Međutim, ovo nije dobro:

Code:

class A{};

A& vratiObjekat()
{
    A a;

    return a;
}


Onog trenutka kada izađeš iz funkcije - objekat više ne postoji, bio je na steku, obrisan je, a ti očekuješ da ćeš proslediti referencu na njega - na nešto što ne postoji.

Evo šta kaže g++:

warning: reference to local variable ‘a’ returned
[ azzpoz @ 24.11.2013. 18:09 ] @
Zašto je problem otklonjen dodavanjem const???

Da li je to "UGRAĐENI" metod za prihvatanje reference kao konstante???

[Ovu poruku je menjao azzpoz dana 24.11.2013. u 19:37 GMT+1]
[ Burgos @ 24.11.2013. 19:02 ] @
Problem je otklonjen jer se u tom slučaju garantuje da nećeš promeniti taj objekat. Dakle, ne smeš da menjaš objekat koji će uskoro nestati (kome ne možeš da pristupiš direktno, pa je za tebe već nestao, samo služi tu da se dodeli vrednost) - to je mehanizam zaštite.
[ azzpoz @ 24.11.2013. 19:04 ] @
Da nisam koristio const, objekat koji je na steku bi se obrisao, jer ga ništa ne "prihvata" kao const ... &, da li je tako???
[ Burgos @ 24.11.2013. 19:10 ] @
Da si napisao:

Code:
mojstring &operator=(mojstring i)


ovo bi bilo ispravno (mada ne i efikasno) zato što bi se pre nego što se uđe u telo funkcije stvorila kopija privremenog objekta, i privremeni objekat bi nestao - ne bi postojala referenca na njega - ti bi radio samo sa kopijom.
[ azzpoz @ 24.11.2013. 21:02 ] @
Ukapirao sam neke dijelove...

Hvala