return value optimization

[aaragon]

Hi,

I'm designing a Matrix class so I read what Bjarne Stroustrup has on
section 22.4.6 about it. It shows that it is possible to eliminate the
temporaries by delaying the construction of the object. In his example
(page 675):

struct MVmul {
const Matrix& m;
const Vector& m;

MVmul(const Matrix& mm, const Vector& vv) : (mm), v(vv) { }
operator Vector(); // evaluate and return result
};

inline MVmul operator*(const Matrix& mm, const Vector& vv)
{
return MVmul(mm,vv);
}

Now, I think that's cool, however, I have a question about the
converting function operator Vector(). The implementation could be
done there OR it can be done as a constructor of the Vector class,
right? Something like this:

class Vector {
// member variables
...
public:
// constructors
...
Vector(const MVmul& mvmul) {
// evaluate
}
...
// rest of the class
};

Now the question is, is an approach better than the other? I think
that both are equivalent, but I wanted to make sure asking to the
experts...

Thank you,

a²

[Kira Yamato]

On 2007-12-04 00:26:52 -0500, aaragon <al**************@gmail.comsaid:

Hi,

I'm designing a Matrix class so I read what Bjarne Stroustrup has on
section 22.4.6 about it. It shows that it is possible to eliminate the
temporaries by delaying the construction of the object. In his example
(page 675):

struct MVmul {
const Matrix& m;
const Vector& m;

MVmul(const Matrix& mm, const Vector& vv) : (mm), v(vv) { }
operator Vector(); // evaluate and return result
};

inline MVmul operator*(const Matrix& mm, const Vector& vv)
{
return MVmul(mm,vv);
}

Now, I think that's cool, however, I have a question about the
converting function operator Vector(). The implementation could be
done there OR it can be done as a constructor of the Vector class,
right? Something like this:

class Vector {
// member variables
...
public:
// constructors
...
Vector(const MVmul& mvmul) {
// evaluate
}
...
// rest of the class
};

Now the question is, is an approach better than the other? I think
that both are equivalent, but I wanted to make sure asking to the
experts...

Definitely in the MVmul class.

--

-kira

[aaragon]

On Dec 4, 2:05 am, Kira Yamato <[e-mail]:

On 2007-12-04 00:26:52 -0500, aaragon <[e-mail]:

Hi,

I'm designing a Matrix class so I read what Bjarne Stroustrup has on
section 22.4.6 about it. It shows that it is possible to eliminate the
temporaries by delaying the construction of the object. In his example
(page 675):

struct MVmul {
const Matrix& m;
const Vector& m;

MVmul(const Matrix& mm, const Vector& vv) : (mm), v(vv) { }
operator Vector(); // evaluate and return result
};

inline MVmul operator*(const Matrix& mm, const Vector& vv)
{
return MVmul(mm,vv);
}

Now, I think that's cool, however, I have a question about the
converting function operator Vector(). The implementation could be
done there OR it can be done as a constructor of the Vector class,
right? Something like this:

class Vector {
// member variables
...
public:
// constructors
...
Vector(const MVmul& mvmul) {
// evaluate
}
...
// rest of the class
};

Now the question is, is an approach better than the other? I think
that both are equivalent, but I wanted to make sure asking to the
experts...

Definitely in the MVmul class.

--

-kira

Why?

[terminator]

On Dec 4, 5:05 pm, aaragon <[e-mail]:

On Dec 4, 2:05 am, Kira Yamato <[e-mail]:

On 2007-12-04 00:26:52 -0500, aaragon <[e-mail]:

Hi,

I'm designing a Matrix class so I read what Bjarne Stroustrup has on
section 22.4.6 about it. It shows that it is possible to eliminate the
temporaries by delaying the construction of the object. In his example
(page 675):

struct MVmul {
const Matrix& m;
const Vector& m;

MVmul(const Matrix& mm, const Vector& vv) : (mm), v(vv) { }
operator Vector(); // evaluate and return result
};

inline MVmul operator*(const Matrix& mm, const Vector& vv)
{
return MVmul(mm,vv);
}

Now, I think that's cool, however, I have a question about the
converting function operator Vector(). The implementation could be
done there OR it can be done as a constructor of the Vector class,
right? Something like this:

class Vector {
// member variables
...
public:
// constructors
...
Vector(const MVmul& mvmul) {
// evaluate
}
...
// rest of the class
};

Now the question is, is an approach better than the other? I think
that both are equivalent, but I wanted to make sure asking to the
experts...

Definitely in the MVmul class.

--

-kira

Why?

It(MVmul) has to convert its second argument to a Vector in either
case.

regards,
FM.

[aaragon]

On Dec 4, 8:28 am, terminator <[e-mail]:

On Dec 4, 5:05 pm, aaragon <[e-mail]:

On Dec 4, 2:05 am, Kira Yamato <[e-mail]:

On 2007-12-04 00:26:52 -0500, aaragon <[e-mail]:

Hi,

I'm designing a Matrix class so I read what Bjarne Stroustrup has on
section 22.4.6 about it. It shows that it is possible to eliminate the
temporaries by delaying the construction of the object. In his example
(page 675):

struct MVmul {
const Matrix& m;
const Vector& m;

MVmul(const Matrix& mm, const Vector& vv) : (mm), v(vv) { }
operator Vector(); // evaluate and return result
};

inline MVmul operator*(const Matrix& mm, const Vector& vv)
{
return MVmul(mm,vv);
}

Now, I think that's cool, however, I have a question about the
converting function operator Vector(). The implementation could be
done there OR it can be done as a constructor of the Vector class,
right? Something like this:

class Vector {
// member variables
...
public:
// constructors
...
Vector(const MVmul& mvmul) {
// evaluate
}
...
// rest of the class
};

Now the question is, is an approach better than the other? I think
that both are equivalent, but I wanted to make sure asking to the
experts...

Definitely in the MVmul class.

--

-kira

Why?

It(MVmul) has to convert its second argument to a Vector in either
case.

regards,
FM.

No, that second argument is untouchable. Is passed as a constant
reference. A new vector is created within the operator Vector()
implementation. So I believe both approaches are equivalent.

a²

[Kira Yamato]

On 2007-12-04 17:29:50 -0500, aaragon <al**************@gmail.comsaid:

On Dec 4, 8:28 am, terminator <[e-mail]:

>On Dec 4, 5:05 pm, aaragon <[e-mail]:

>>On Dec 4, 2:05 am, Kira Yamato <[e-mail]:

>>>On 2007-12-04 00:26:52 -0500, aaragon <[e-mail]

d:

>>

>>>>Hi,

>>>>I'm designing a Matrix class so I read what Bjarne Stroustrup has on

>>>>section 22.4.6 about it. It shows that it is possible to eliminate t

he

>>>>temporaries by delaying the construction of the object. In his examp

le

>>>>(page 675):

>>>>struct MVmul {
const Matrix& m;
const Vector& m;

>>>>MVmul(const Matrix& mm, const Vector& vv) : (mm), v(vv) { }
operator Vector(); // evaluate and return result
};

>>>>inline MVmul operator*(const Matrix& mm, const Vector& vv)
{
return MVmul(mm,vv);
}

>>>>Now, I think that's cool, however, I have a question about the
converting function operator Vector(). The implementation could be
done there OR it can be done as a constructor of the Vector class,
right? Something like this:

>>>>class Vector {
// member variables
...
public:
// constructors
...
Vector(const MVmul& mvmul) {
// evaluate
}
...
// rest of the class
};

>>>>Now the question is, is an approach better than the other? I think
that both are equivalent, but I wanted to make sure asking to the
experts...

>>>Definitely in the MVmul class.

>>>--

>>>-kira

>>Why?

It(MVmul) has to convert its second argument to a Vector in either
case.

regards,
FM.

No, that second argument is untouchable. Is passed as a constant
reference. A new vector is created within the operator Vector()
implementation. So I believe both approaches are equivalent.

a²

Equivalent in functionality, maybe. But certainly not in design.

Just imagine what if in the near future, you want to introduce lazy
evaluation for the inner product of two vectors VVinner.

Next, think about what kind of changes is needed in both approaches you
mentioned. And before you attempt to answer that question, first
google up "idea behind encapsulation."

--

-kira

[aaragon]

On Dec 4, 6:05 pm, Kira Yamato <[e-mail]:

On 2007-12-04 17:29:50 -0500, aaragon <[e-mail]:

On Dec 4, 8:28 am, terminator <[e-mail]:

On Dec 4, 5:05 pm, aaragon <[e-mail]:

>On Dec 4, 2:05 am, Kira Yamato <[e-mail]:

>>On 2007-12-04 00:26:52 -0500, aaragon <[e-mail]

d:

>>>Hi,

>>>I'm designing a Matrix class so I read what Bjarne Stroustrup has on

>>>section 22.4.6 about it. It shows that it is possible to eliminate t

he

>>>temporaries by delaying the construction of the object. In his examp

le

>>>(page 675):

>>>struct MVmul {
const Matrix& m;
const Vector& m;

>>>MVmul(const Matrix& mm, const Vector& vv) : (mm), v(vv) { }
operator Vector(); // evaluate and return result
};

>>>inline MVmul operator*(const Matrix& mm, const Vector& vv)
{
return MVmul(mm,vv);
}

>>>Now, I think that's cool, however, I have a question about the
converting function operator Vector(). The implementation could be
done there OR it can be done as a constructor of the Vector class,
right? Something like this:

>>>class Vector {
// member variables
...
public:
// constructors
...
Vector(const MVmul& mvmul) {
// evaluate
}
...
// rest of the class
};

>>>Now the question is, is an approach better than the other? I think
that both are equivalent, but I wanted to make sure asking to the
experts...

>>Definitely in the MVmul class.

>>--

>>-kira

>Why?

It(MVmul) has to convert its second argument to a Vector in either
case.

regards,
FM.

No, that second argument is untouchable. Is passed as a constant
reference. A new vector is created within the operator Vector()
implementation. So I believe both approaches are equivalent.

a²

Equivalent in functionality, maybe. But certainly not in design.

Just imagine what if in the near future, you want to introduce lazy
evaluation for the inner product of two vectors VVinner.

Next, think about what kind of changes is needed in both approaches you
mentioned. And before you attempt to answer that question, first
google up "idea behind encapsulation."

--

-kira

Well, you have a point there since I plan to have several of these
little structures. However, the question behind my original post was
referring to extra overhead from any of the both approaches, and
unless someone else tells me otherwise, both are equivalent when
creating the object. Right?

a²