C++,class，一个 function 返回一个 ZA8CFDE6331BD59EB2AC96F8911C4B666

Question

I wrote a Class called Point and want to write a function that takes 2 Points and sum them.

why I should write it as the following:

Point SumPoints(Point& p1, Point& p2)
{
    Point result(p1->x + p2->x, p1->y + p2->y);
    return result;
}

won't it be more efficient to define a pointer the the result and return it? (instead of defining a new Point 'result' and then copying it again in main)

Plus, I'm a little bit confused about when the copy function is being called automatically? is that true that whenever I type = it will be called?

Answer 1

Here, it is perfectly valid to return result by value. Modern compilers will apply NRVO named return value optimization such that no copying is required. It would be more confusing if a pointer is returned by a sum operation.

Regarding you other question (if I got that correctly), using = does not always involve copying. For instance, there is also a move assignment operator which simply moves an rvalue reference into an object instead of copy it. There are also cases where copy elision applies (same link as above) and allows to completely avoid copy and move semantics.

In the following example you can see that copying or moving is mostly omitted by the compiler ( live demo )

#include <string>
#include <iostream>
#include <iomanip>

struct Point{ 
    Point() = default;
    Point(double x, double y):x(x),y(y){}

    Point(const Point &p):x(p.x),y(p.y){
        std::cout << "copy construct" << std::endl;}

    Point(Point&& p):x(std::move(p.x)),y(std::move(p.y)){
        std::cout << "move construct" << std::endl;}

    Point& operator=(const Point& p){
        x = p.x; 
        y = p.y; 
        std::cout << "copy assign" << std::endl; 
        return *this;
    }
    Point& operator=(Point&& p){
        x = std::move(p.x); 
        y = std::move(p.y); 
        std::cout << "move assign" << std::endl; 
        return *this;
    }
    double x,y;
};

std::ostream& operator<<(std::ostream& out, const Point& p)
{
    out << std::setw(5) << p.x << std::setw(5) << p.x << std::flush;
    return out;
}

Point operator+(const Point& p1, const Point &p2)
{
    return Point(p1.x+p2.x,p1.y+p2.y);
}

Point sum1(const Point& p1, const Point &p2)
{
    return Point(p1.x+p2.x,p1.y+p2.y);
}

Point sum2(const Point& p1, const Point &p2)
{
    Point result;
    result.x = p1.x+p2.x;
    result.y = p1.y+p2.y;
    return result;
}

int main()
{
    Point p1(1,0), p2(0,1);
    auto r1 = sum2(p1,p2);
    auto r2 = sum1(p1,p2);
    auto r3 = r1+r2; 
    auto r4 = r3; // <- only this calls the copy constructor

    std::cout << "r3 = ("<< r3 << ")"<< std::endl;
}

This prints:

copy construct
r3 = (    2    2)

As a hint, you can overload the + operator as shown in the example to write the summation in a more readable way.

Answer 2

won't it be more efficient to define a pointer the the result and return it?

If you don't create an object, then there wouldn't be anything for the pointer to point to.

It would also be highly confusing and un-conventional to return a pointer from addition operator.

and then copying it again in main

It won't necessarily be copied at all if the optimiser manages to elide the copy.

If you're initialising an object with the result rather than assigning, you can make sure that there won't be a copy by returning a prvalue:

return Point(p1->x + p2->x, p1->y + p2->y);