CODE

Question

在成员函数getPoints（）中使用vector显示奇怪的行为。

将新对象推送到矢量后，将为先前的对象分配新值。

当向量返回时，我得到了垃圾值。

向量没有存储或使用参考变量。

有人可以解释发生了什么事。

谢谢。

CODE

#include<iostream>
#include<vector>
#include<math.h>

using namespace std;


class Unit{
public:

    double n[2];
    double &x = n[0], &y = n[1];

    Unit(double x=0, double y=0){
        n[0] = x;
        n[1] = y;
    }

    Unit& operator=(const Unit& rhs){
        this->x = rhs.x;
        this->y = rhs.y;
        return *this;
    }

    Unit& operator+=(const Unit& rhs){
        this->x += rhs.x;
        this->y += rhs.y;
        return *this;
    }

    Unit operator+(const Unit& rhs){
        return Unit(x+rhs.x, y+rhs.y);
    }

    Unit& operator-=(const Unit& rhs){
        this->x -= rhs.x;
        this->y -= rhs.y;
        return *this;
    }

    Unit operator-(const Unit& rhs){
        return Unit(x-rhs.x, y-rhs.y);
    }

    Unit& operator*=(const Unit& rhs){
        this->x *= rhs.x;
        this->y *= rhs.y;
        return *this;
    }

    Unit operator*(const Unit& rhs){
        return Unit(x*rhs.x, y*rhs.y);
    }

    Unit operator*=(double rhs){
        this->x *= rhs;
        this->y *= rhs;
        return *this;
    }

    Unit operator*(double rhs){
        return Unit(x*rhs, y*rhs);
    }

    Unit operator/=(const Unit& rhs){
        this->x /= rhs.x;
        this->y /= rhs.y;
        return *this;
    }

    Unit operator/(const Unit& rhs){
        return Unit(x/rhs.x, y/rhs.y);
    }

    Unit operator/=(double rhs){
        this->x /= rhs;
        this->y /= rhs;
        return *this;
    }

    Unit operator/(double rhs){
        return Unit(x/rhs, y/rhs);
    }

    double dot(const Unit& rhs){
        return x * rhs.x + y * rhs.y;
    }

    double len2(){
        return dot(*this);
    }

    double len(){
        return sqrt(len2());
    }

    double distance2(const Unit& rhs){
        Unit C = *this - rhs;
        return C.len2();
    }

    double distance(const Unit& rhs){
        return sqrt(distance2(rhs));
    }

    Unit Normalize(){ 
        return *this * 1.0 / len(); 
    }

    Unit Round(){
        return Unit(round(x), round(y));
    }

    Unit Trunc(){
        return Unit(int(x), int(y));
    }

    vector<Unit> getPoints(const Unit& rhs){

        vector<Unit> points;

        Unit start, end;

        if(x < rhs.x){

            start = *this;
            end = rhs;
        }
        else{

            start = rhs;
            end = *this;
        }

        int run = end.x - start.x;
        int rise = end.y - start.y;

        double m = ((double) rise) / ((double) run);

        double b = start.y - (m * start.y);

        for(int i = start.x; i < end.x; ++i){

            double y = (m * i) + b;

            int rounded = (y > 0.0) ? floor(y + .50) : ceil(y - 0.5);

            points.push_back(Unit(i, i));
            cout<<"Expected Output : "<< points[points.size()-1].x << " " << points[points.size()-1].y <<endl;
        }

        cout << endl;

        for (auto&p : points){

            cout<<"Actual Output : "<< p.x << " " << p.y << endl;
        }

        return points;

    }
};


int main()
{
    Unit a, b(10,10);

    auto c = a.getPoints(b);

    cout <<endl;

    for(auto& d: c){

        cout<<"Recieved Output : "<< d.x << " " << d.y << endl;
    }

    return 0;
}

输出

Expected Output : 0 0
Expected Output : 1 1
Expected Output : 2 2
Expected Output : 3 3
Expected Output : 4 4
Expected Output : 5 5
Expected Output : 6 6
Expected Output : 7 7
Expected Output : 8 8
Expected Output : 9 9

Actual Output : 9 9
Actual Output : 9 9
Actual Output : 9 9
Actual Output : 9 9
Actual Output : 9 9
Actual Output : 9 9
Actual Output : 9 9
Actual Output : 9 9
Actual Output : 9 9
Actual Output : 9 9

Recieved Output : 2.07386e-317 6.9151e-310
Recieved Output : 6.9151e-310 6.95256e-310
Recieved Output : 6.9151e-310 6.95256e-310
Recieved Output : 6.9151e-310 6.95256e-310
Recieved Output : 6.9151e-310 6.95256e-310
Recieved Output : 6.9151e-310 6.95256e-310
Recieved Output : 6.9151e-310 6.95256e-310
Recieved Output : 6.9151e-310 6.95256e-310
Recieved Output : 6.9151e-310 6.95256e-310
Recieved Output : 6.9151e-310 6.95256e-310

Answer 1

您的课程中包含参考变量。

当您通过默认的copy-constructor复制类时，新对象的引用变量将引用源引用所引用的 same 对象。在这种情况下，它将是源对象的成员变量。

您可能希望每个Unit的引用都引用同一Unit的成员。为此，您将需要编写自己的复制构造函数，以适当地初始化引用。（并且您也应该编写一个移动构造函数。）

NB。更好的方法是根本不使用参考变量。您可以改用成员函数double& x() { return n[0]; }。

向量push_back更改先前元素的值。

CODE

输出

1 个答案: