Question

是否可以设置指向值的指针，但略有偏移。

类似的东西：

m_NewPosition = &m_Position + Vector3(0,0,10);

因此，NewPosition的值是实际位置加上10前方。

使用c ++。

Answer 1

如果指针指向数组，则只能使用带指针的偏移量。

因此，如果您有char arr[10];并填写了某些内容，那么您可以执行char *p = arr + calc_offset();，前提是您不要超出数组范围。

来自C ++标准：

如果指针操作数和结果都指向了元素相同的数组对象，或者超过数组对象的最后一个元素，评估不得产生溢流;否则，行为是未定的。

Answer 2

是的，您可以对指针执行算术运算，但除非新指向的地址指向有效解除引用的内容，否则将导致UB。

Answer 3

听起来你正在寻找的是一个函数，其结果随m_Position的值而变化。我通过m_前缀认为这些都是成员。如果m_Position + Vector3(0,0,10)是常量，它可能只是一个普通的成员函数：

Vector3 m_NewPosition() const {
    return m_Position + Vector(0,0,10);
}

但是如果你想要能够改变这个功能，那么你可以使用std::function<Vector3(void)>，并像这样分配它：

m_NewPosition = [&m_Position]() { return m_Position + Vector3(0,0,10); };

这是一个简单的例子，但是用整数代替向量。

#include <iostream>
#include <functional>

struct Foo
{
    Foo()
        :X(0)
    {
        NewX = [&X]() { return X + 10; };
    }

    int X;
    std::function<int(void)> NewX;
};

int main()
{
    Foo f;
    for (f.X=0; f.X<10; ++f.X)
    {
        std::cout << f.NewX() << '\n';
    }
}

在线演示，以便您查看其输出：http://ideone.com/XTwE7

另一个选择是确保m_Position和m_NewPosition都是私有的，不要直接修改它们，而只能通过访问器函数修改它们，例如

class Foo
{
public:
    void IncrementPosition(const Vector3 & rhs)
    {
        m_Position += rhs;
        m_NewPosition = m_Position + Vector3(0,0,10);
    }
private:
    Vector3 m_Position, m_NewPosition;
};

Answer 4

您希望获取m_Position的地址并向其添加矢量，这似乎很奇怪。如果我们知道你的指针在哪里，也许它会对我们有所帮助。我们不知道m_NewPosition或m_Position的类型，因此很难提供帮助。但是，你似乎根本不需要指针。

我将假设这两个变量的类型为Position，这个类看起来像：

class Position {
 public:
  Position(int x, int y, int z) : x(x), y(y), z(z) { }
 private:
  int x;
  int y;
  int z;
}

如果是这种情况，并且您想要将Vector3作为第二个操作数应用于此位置，那么您需要在此类上重载operator+。要做到这一点，做这样的事情：

class Position {
 public:
  Position(int x, int y, int z) : x(x), y(y), z(z) { }
  Position operator+(const Vector3& vector) {
    return Position(x + vector.x, y + vector.y, z + vector.z);
  }
 private:
  int x;
  int y;
  int z;
}

如您所见，operator+方法允许您向此位置添加矢量。现在你可以这样做：

m_NewPosition = m_Position + Vector3(0,0,10);

但是，在此示例中，m_Position不会更改。它将一如既往地保持不变。对operator+的调用只返回带有更新组件的新Position。如果您想要更新m_Position，那么您可能希望重载operator+=。

Answer 5

如果我理解正确，你希望m_NewPosition始终等于m_Position加上一些空间偏移，即使它被修改（reactive programming行）。这是你试图做到的方式无法实现的，你应该找到一些关于指针的好参考。但是，您可以使用一些解决方案。

第一个是使用函数/方法like @Benjamin Lindley proposed：由于NewPosition是计算值，因此在函数中计算它是有意义的：

class Character
{
  public:
    Vector3 getPosition() const
    {
        return m_Position;
    }

    Vector3 getNewPosition() const
    {
        return getPosition() + Vector3(0, 0, 10);
    }

  private:
    Vector3 m_Position;
};

这是封装的整个过程，意味着隐藏对象的内部：对象的“可见”属性应该只能通过成员函数（方法）访问，允许您更改它们的存储方式或计算它们是动态的，就像你的例子中的m_NewPosition一样。

另一种解决方案，更复杂（在您的情况下可能不合适），是编写一个代表相对位置的新类：

class RelativePosition
{
  public:
    RelativePosition(Vector3 const & origin, Vector3 const & offset)
      : m_Origin(origin), m_Offset(offset)
    {}

    Vector3 getAbsolutePosition() const
    {
        return m_Origin + m_Offset;
    }

  private:
    Vector3 const & m_Origin;
    Vector3 m_offset;
};

请注意RelativePosition如何存储对其来源的引用，而不是副本;因此，如果原点被修改（即移动），相对位置将反映这一变化。

现在，您可以使用此类的实例来表示m_newPosition，这实际上是一个相对位置（相对于m_Position，偏移量为“Vector3（0,0,10）” 。但是，正如我之前所说，我认为这种解决方案可能对您的案件有些过分;你应该坚持以前的做法。

将指针设置为值加上单独的值

5 个答案: