Re: How to use operator overloading?

Thank you for explaining about operator overloading. Operator+ should
always return data by value.

#Hi to all
#it can return data by referece too (see below)
#in few i know all operators can work on referece (pointers)
#and this could be a very good thing

operator+= and operator= always return
data by reference.

#for operator+= is ok referece but i think operator= can return
#data by value (one temporaly object) too (so referece or value)

After "C = B + A;" is read by C++ Compiler, operator+ is called and
data is returned by value before operator= is called and pass data by
value from operator+ and return it by reference.

#if operator+ return a referece of some already existing memory
#can return the referece of that memory
#example:
#if i have "t& operator+(t& )" and "t& operator=()"
#in a=b+c
# first it call operator+ from b and c [from reference]
# and return the referece
# to static memory that has the object of the result.
# operator= use the reference of the result and copy on a

You did post your words to state that operator+ should use data by
value only or do both data by value and data by reference on depend of
object design. Not a problem.

I know the difference between shadow copy and deep copy.

#i don't, what is the differnce?

Deep copy is
used if you create dynamic data array at run-time. Shadow copy should
be avoided because both objects cannot share dynamic data array or
memory leak will happen.

#i don't understand much

I read a book. The book is excellent. It explains everything like
you stated earlier. The title name is Objects, Abstraction, Data
Structures and Design using C++. Arthor's name Elliot B. Koffman and
Paul A.T. Wolfgang. ISBN 0-471-46755-3.

#i have one different book
#this is my example
------------------------------
#include <iostream>
// #include <cstdlib>
// #include <cstdio>
// #include <vector>
#include <string>
#include <stdint.h>

#define u8 uint8_t
#define i8 int8_t
#define u32 uint32_t
#define i32 int32_t
// float 32 bits
#define f32 float

#define S sizeof
#define R return
#define P printf
#define F for
#define G goto

using namespace std;

class test;

class test
{public:
 string s;

 test() { s=""; }
 test(i8* a) { s=a; }
~test() { }

// this is lile v=r
test& operator= (test& r){s =r.s; R *this;}

// this calculate a+b and return its result
// i can not write it withot the use of "friend"
// NB.
// one expression can have Max 16 level of ()
test& operator+ (test& r);
test& operator+ (){R *this;}

// this is in a+=b
test& operator+=(test& r){s+=r.s; R *this;}

friend ostream& operator<<(ostream& ost, test& b)
{ost << b.s << flush; R ost;}

};

// array of the results
u32 index=0;
test v[16]; // 0..15

test& test::operator+(test& a)
{u32 u=index;
 v[u].s = s;
 v[u].s+=a.s;
 ++index; if(index==16) index=0;
 R v[u];
}

int main(void)
{test t("t0s_"), t1("t1_s"), t2("t2s_"), t3("t3s_");

 t + t2; // ???
 // 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 t =t+t1+t2+t3+ t+t1+t2+t3+ t+t1+t2+t3+ t+t1+t2+t3+ t+t1+t2+t3;
 cout << t << "\n";
 R 0;
}
-------
t0s_t1_st2s_t3s_t0s_t1_st2s_t3s_t0s_t1_st2s_t3s_t0s_t1_st2s_t3s_t0s_t1_st2s_t3s_
-------
do you know what operation to do for make the operator+ give the wrong result?