c++；：Can'；t修改类对象参数 我最近在C++项目中创建了两个类，一个是播放器类，另一个是向量类（不是数组）。

Player.h

#ifndef Player_h
#define Player_h

#include <iostream>
#include <string>
#include <cmath>

/* Player */
 class Player{
 public:
    /* Constructor */
    Player(std::string name = "name", double x = 0, double y = 0, double z = 0);
    Player(const Player& player);

    /* Methods */
    void position(double x, double y, double z);
    void velocity(double x, double y, double z);

    /* Read only */
    Vector position() const;
    Vector velocity() const;

    /* Operator */
    friend std::ostream& operator<<(std::ostream& stream, const Player& player);
 private:
    std::string m_name;
    Vector m_position;
    Vector m_velocity;
};

/* Constructor */
 Player::Player(std::string name, double x, double y, double z)
: m_name(name), m_position(x, y, z), m_velocity(0){}

 Player::Player(const Player& player)
: m_name(player.m_name), m_position(player.m_position), m_velocity(player.m_velocity){}

/* Methods */
 void Player::position(double x, double y, double z){
    m_position.x(x);
    m_position.y(y);
    m_position.z(z);
}

 void Player::velocity(double x, double y, double z){
    m_velocity.x(x);
    m_velocity.y(y);
    m_velocity.z(z);
}

/* Read only */
 Vector Player::position() const{ return m_position; }
 Vector Player::velocity() const{ return m_velocity; }

/* Operator */
 std::ostream& operator<<(std::ostream& stream, const Player& player){
    stream << player.m_name << " >> pos" << player.m_vector << "";
    return stream;
}
/* Player */

#endif /* Player_h */

#ifndef Vector_h
#define Vector_h

#include <iostream>
#include <string>
#include <cmath>

/* Vector */
 class Vector{
 public:
    /* Constructor */
    Vector(double x = 0, double y = 0, double z = 0);
    Vector(const Vector& vec);

    /* Methods */
    void x(double x);
    void y(double y);
    void z(double z);
    double norm();

    /* Read only */
    double x() const;
    double y() const;
    double z() const;
    bool isEqual(const Vector &vec) const;

    /* Operator & Cie */
    friend std::ostream& operator<<(std::ostream& stream, const Vector& vec);
    Vector& operator+=(const Vector& vec);
    Vector& operator-=(const Vector& vec);
    friend Vector operator+(const Vector& vecA, const Vector& vecB);
    friend Vector operator-(const Vector& vecA, const Vector& vecB);
    friend bool operator==(const Vector& vecA, const Vector& vecB);
    friend bool operator!=(const Vector& vecA, const Vector& vecB);
    friend bool operator<(const Vector& vecA, const Vector& vecB);
    friend bool operator>(const Vector& vecA, const Vector& vecB);
    friend bool operator<=(const Vector& vecA, const Vector& vecB);
    friend bool operator>=(const Vector& vecA, const Vector& vecB);
 private:
    double m_x;
    double m_y;
    double m_z;
};

/* Constructor */
 Vector::Vector(double x, double y, double z)
: m_x(x), m_y(y), m_z(z) {
    if(x != 0 && y == 0 && z == 0){
        m_y = x;
        m_z = x;
    }
}

Vector::Vector(const Vector& vec)
: m_x(vec.m_x), m_y(vec.m_y), m_z(vec.m_z) {}

/* Methods */
 void Vector::x(double x){ m_x = x; }
 void Vector::y(double y){ m_y = y; }
 void Vector::z(double z){ m_z = z; }

 double Vector::norm(){
    return sqrt(pow(m_x, 2) + pow(m_y, 2) + pow(m_z, 2));
}

/* Read only */
 double Vector::x() const{ return m_x; }
 double Vector::y() const{ return m_y; }
 double Vector::z() const{ return m_z; }

 bool Vector::isEqual(const Vector &vec) const{
    return m_x == vec.m_x && m_y == vec.m_y && m_z == vec.m_z;
}

/* Operator & Cie */
 std::ostream& operator<<(std::ostream& stream, const Vector& vec){
    stream << "(" << vec.m_x << "; " << vec.m_y << "; " << vec.m_z << ")";
    return stream;
}

 Vector& Vector::operator+=(const Vector& vec){
    m_x += vec.x();
    m_y += vec.y();
    m_z += vec.z();
    return *this;
}

 Vector& Vector::operator-=(const Vector& vec){
    m_x -= vec.x();
    m_y -= vec.y();
    m_z -= vec.z();
    return *this;
}

 Vector operator+(const Vector& vecA, const Vector& vecB){
    Vector result(vecA);
    result += vecB;
    return result;
}

 Vector operator-(const Vector& vecA, const Vector& vecB){
    Vector result(vecA);
    result -= vecB;
    return result;
}

 bool operator==(const Vector& vecA, const Vector& vecB){ return vecA.m_x == vecB.m_x && vecA.m_y  == vecB.m_y && vecA.m_z == vecB.m_z; }
 bool operator!=(const Vector& vecA, const Vector& vecB){ return !(vecA == vecB); }
 bool operator<(const Vector& vecA, const Vector& vecB){
    Vector copyA(vecA), copyB(vecB);
    return copyA.norm() < copyB.norm();
}
 bool operator>(const Vector& vecA, const Vector& vecB){ return !(vecA < vecB); }
 bool operator<=(const Vector& vecA, const Vector& vecB){ return vecA < vecB || vecA == vecB; }
 bool operator>=(const Vector& vecA, const Vector& vecB){ return vecA > vecB || vecA == vecB; }
/* Vector */

#endif /* Vector_h */

我认为我必须使用指针或地址，但我不知道如何使用。]

已解决 [我怎样才能做到这一点？：

player.position().x(5);

player.position().x() += 5;]

position（）返回值的副本。所以，您可以更改该值，但玩家不会知道这一点。 您可以创建方法Player:：set_position（Vector new_val）并将新值更新到Player中。

position（）返回值的副本。因此，您可以更改该值，但Player不会知道这一点。 您可以创建方法Player:：set_position（Vector new_val）并将新值更新到Player中。

position（）

返回一个副本。如果您希望能够像这样直接修改成员，则应将其作为参考返回：

Vector& Player::position() { return m_position; }

现在请注意，“只读”没有任何意义，因为消费者可以通过此方法修改位置。

position（）

返回一个副本。如果您希望能够像那样直接修改成员，则应将其作为参考返回：

Vector& Player::position() { return m_position; }

---

现在请注意“只读”没有任何意义，因为消费者可以通过此方法修改位置。

谢谢杜德，它工作得很好！实际上，

private

也是有争议的。一旦你提供了一个非常量引用，成员就不再被封装。谢谢杜德，它工作得很好！实际上，

private

也是有争议的。一旦你提供了一个非常量引用nst引用成员不再被封装。