0

我最近在我的 c++ 项目中创建了两个类，一个是 Player 类，另一个是 Vector 类（不是数组）。

播放器.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 */

矢量.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 */

主要的

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

#include "Vector.h"
#include "Player.h"

/* Main */
 int main(int argc, char* argv[]){
    Player player("Joueur 1");

    player.position(-10, 65, 876);
    player.position().x(5);

    std::cout << player.position() << std::endl;

    std::cin.get();
}
/* Main */

因此，在我的 Vector 类中，我创建了一个允许修改 x、y 和 z 值的方法。(void x(double x); void y(double y); void z(double z);) 在我的播放器类中，我创建了一个允许访问播放器位置（向量）的方法。（向量位置（）常量；）

已解决 [我的问题是为什么我不能这样修改玩家 x_position？：

player.position().x(5);

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

已解决 [我该怎么做？：

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

2 回答 2

2

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

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

现在请注意，“只读”不再有意义，因为消费者可以通过这种方法修改位置。

于 2021-04-09T08:32:26.530 回答
0

position() 返回值的副本。因此，您可以更改该值，但玩家不会知道这一点。您可以创建方法 Player::set_position(Vector new_val) 并将新值更新到 player..

于 2021-04-09T08:31:38.293 回答