Re: Operatr+ Updated
On 02/20/11 09:04 AM, Nephi Immortal wrote:
I read the topic ? "Error operator+ function? in the previous
thread. Other folks explained how to put three possible operator+
functions.
I wrote two versions of class A and class B. Both classes are
similar, but one data member of class B uses reference instead of
value.
I cannot use class A version. I am told not to use copy constructor
function. If I do, then copy constructor will have undefined
behavior. I should always place it in private.
Told by whom and in what context?
They said not to put const on any function?s parameter if parameter
is built-in type such as int.Please clarify why I should not use
> const?
That's because it doesn't have any meaning for a value parameter (the
same would apply for any type passed by value).
Const is necessary to prevent changing parameter and I always
create temporary local variable and copy const parameter to it.
That only applies if the parameter is a reference or a pointer. Both of
these refer to objects in the scope of the caller, so declaring the
parameter const prevents the called function changing the original
value. Value parameters are copies of the original, Changing them has
no effect on the the original.
Take a look at class A and class B. Compare both of them. Class B
is ideal to be helper class or proxy class.
You can write like
_Low_Byte Low_Byte()
and
_High_Byte High_Byte()
Both functions are in class A.
You can create two classes: _Low_Byte and _High_Byte. The class B is
inherited into _Low_Byte class and _High_Byte class. You need to
redefine operator=.
This is hard to parse.
I do not need to post two classes since you understood what my code
means.
I believe that class A is to be correct code design. What about
class B?
class A {
public:
explicit A( unsigned int data );
~A();
A( const A&right );
A&operator=( const A&right );
A&operator=( unsigned int data );
operator unsigned int();
friend A operator+( const A&left, const A&right );
friend A operator+( const A&left, unsigned int right );
friend A operator+( unsigned int left, const A&right );
>
friend A operator+=( const A&left, const A&right );
friend A operator+=( const A&left, unsigned int right );
friend A operator+=( unsigned int left, const A&right );
These should be members, returning A&. += updates the current instance,
it doesn't create a new one.
private:
unsigned int m_data;
};
<snip>
class B {
public:
explicit B( unsigned int&data );
Why do you use an int& here?
I won't comment further, I'm not sure what B is doing.
--
Ian Collins