如何避免在转换函数中使用复制构造函数？

Question

I am trying to convert between two classes and avoid a temporary object.

Here is my declaration for Square :

class CSquare
{
public:
    int dimension;
    CSquare(int dimension);

    // Conversion to Rectangle
    operator CRectangle();

    ~CSquare(void);
};

and here is my declaration for Rectangle :

class CRectangle
{
public:
    int length;
    int width;

    CRectangle(int length, int width);

    //Copy Constructor
    CRectangle(const CRectangle& anotherRectangle); 

    ~CRectangle(void);
};

Why does

CSquare aSquare = CSquare(10);
    CRectangle convertedRect = (CRectangle) aSquare;

invoke the copy constructor?

I have a conversion function:

CSquare::operator CRectangle(){
    return CRectangle(CSquare::dimension,CSquare::dimension);
}

but I'm still getting a temporary object.

How do I avoid the temporary object?

Answer 1

You can avoid copy construction by writing a conversion constructor in CRectangle:

CRectangle::CRectangle(const CSquare & sq)
    :length(sq.dimension),
     width(sq.dimension)
{}
...
...
CSquare aSquare(10);
CRectangle convertedRect(aSquare);

Answer 2

Because you're copying a Rectangle.

I honestly don't know what else to say. Compilers are free to optimize away the call in the case you're showing, but they don't have to. Apparently yours is not.

Edit....

As to how to avoid it, you really can't. You could try to crank up the optimizations but it can be extremely difficult to see if you've succeeded, especially with such a small, trivial construct. If I where you I wouldn't be so worried about it unless I really found, by profiling my code, that an inordinate amount of time was being spent in that function. Then I'd be looking for ways to crunch the algorithms using the code to reduce copies.

Answer 3

How do I avoid the temporary object?

You don't. That's how conversions work. The temporary may be elided (constructing directly into the destination), but that is not required.

It sounds like you want move semantics, which are in C++0x. Even then, the temporary "exists", but it can be moved instead of copied, which, for types where it matters, is often much more efficient.

Is this square/rectangle case not really the situation you care about and only used here for an example?

Answer 4

正在创建一个临时CRectangle对象，然后将其复制到convertRect。

Answer 5

我会假设，因为operator CRectangle返回的实例CRectangle ，拷贝构造函数被调用的返回值。

Answer 6

In general this depends on the compiler. Return value optimization is done by most compiler. So instead of creating a temporary object and assign it to your object the copy Ctor from your object is called.

Also take a look here Copy constructor vs. return value optimization

Answer 7

I can't tell which type of object you're saying has a temporary.

If the square, then you need to remove any excuse for the compiler to create one:

CSquare aSquare(10);

If the rectangle, then you shoudl use a converting constructor instead of an operator, as suggested by @PigBen:

Rectangle::CRectangle(const CSquare & sq)
    :length(sq.dimension),
     width(sq.dimension)
{}
// And then:
CRectangle convertedRect(aSquare);

Answer 8

In this particular case, you do it by not having the conversion function and instead use inheritance. Eg:

class CRectangle
{
public:
    int length;
    int width;

    CRectangle(int length, int width);
};

class CSquare : public CRectangle
{
public:
    CSquare(int dimension) : length(dimension), width(dimension)
    {}
};