我想创建一个名为 pos 的 typedef 结构(从位置开始)，它存储坐标 x 和 y。我正在尝试为此结构重载一些运算符，但它无法编译。

typedef struct {
    int x;
    int y;

    inline pos operator=(pos a) {
        x=a.x;
        y=a.y;
        return a;
    }

    inline pos operator+(pos a) {
        return {a.x+x,a.y+y};
    }

    inline bool operator==(pos a) {
       if (a.x==x && a.y== y)
          return true;
       else
          return false;
    }
} pos;

我也想知道这之间的区别:

inline bool operator==(pos a) {
    if(a.x==x && a.y== y)
       return true;
      else
       return false;
}

还有这个:

bool operator==(pos a) const {
      if(a.x==x && a.y== y)
         return true;
      else
         return false;
}

最佳答案

您的声明及其成员的细目有些乱七八糟:

删除 typedef

typedef 既不是必需的，也不是 C++ 中的类/结构声明所需要的。您的成员不知道 pos 的声明，这是您当前编译失败的核心。

改变这个:

typedef struct {....} pos;

到这里:

struct pos { ... };

删除多余的内联

你在类定义本身中声明和你的成员操作符。 inline 关键字是不需要的，只要你的实现保持在当前位置(类定义)

在适当的地方返回对 *this 的引用

这与您的实现中的大量复制构造有关，如果没有充分的理由，不应该这样做。它与以下的表达思想有关:

a = b = c;

这会将 c 分配给 b，然后将结果值 b 分配给 a。这不等同于以下代码，与您的想法相反:

a = c;
b = c;

因此，您的赋值运算符应该这样实现:

pos& operator =(const pos& a)
{
    x = a.x;
    y = a.y;
    return *this;
}

即使在这里，也不需要这样做。默认的复制分配运算符(operator)将免费为您完成上述操作(和代码!woot!)

注意:有时应避免上述情况，以支持复制/交换习语。虽然在这种特定情况下不需要，但它可能看起来像这样:

pos& operator=(pos a) // by-value param invokes class copy-ctor
{
    this->swap(a);
    return *this;
}

然后实现一个swap方法:

void pos::swap(pos& obj)
{
    // TODO: swap object guts with obj
}

您这样做是为了利用类 copy-ctor 来制作拷贝，然后利用异常安全交换来执行交换。结果是传入的拷贝离开(并破坏)了您的对象的旧内脏，而您的对象承担了那里的所有权。 Read more the copy/swap idiom here ，以及其中的优缺点。

适当时通过 const 引用传递对象

您所有成员的所有输入参数当前正在复制调用时传递的任何内容。虽然对于像这样的代码来说这可能是微不足道的，但对于较大的对象类型来说可能是非常昂贵的。这里给出一个例子:

改变这个:

bool operator==(pos a) const{
    if(a.x==x && a.y== y)return true;
    else return false;
}

至此:(也简化了)

bool operator==(const pos& a) const
{
    return (x == a.x && y == a.y);
}

不会复制任何东西，从而产生更高效的代码。

最后，在回答您的问题时，声明为 const 的成员函数或运算符与未声明的成员函数或运算符有什么区别？

const 成员声明调用该成员不会 修改底层对象(不支持可变声明)。只能针对 const 对象或 const 引用和指针调用 const 成员函数。例如，您的 operator +() 不会修改您的本地对象，因此应声明为 const。您的 operator =() 清楚地修改了本地对象，因此 operator not 应该是 const。

总结

struct pos
{
    int x;
    int y;

    // default + parameterized constructor
    pos(int x=0, int y=0) 
        : x(x), y(y)
    {
    }

    // assignment operator modifies object, therefore non-const
    pos& operator=(const pos& a)
    {
        x=a.x;
        y=a.y;
        return *this;
    }

    // addop. doesn't modify object. therefore const.
    pos operator+(const pos& a) const
    {
        return pos(a.x+x, a.y+y);
    }

    // equality comparison. doesn't modify object. therefore const.
    bool operator==(const pos& a) const
    {
        return (x == a.x && y == a.y);
    }
};

EDIT OP 想看看赋值运算符链是如何工作的。下面演示了这是如何做到的:

a = b = c;

相当于这个:

b = c;
a = b;

而且这并不总是等同于:

a = c;
b = c;

示例代码:

#include <iostream>
#include <string>
using namespace std;

struct obj
{
    std::string name;
    int value;

    obj(const std::string& name, int value)
        : name(name), value(value)
    {
    }

    obj& operator =(const obj& o)
    {
        cout << name << " = " << o.name << endl;
        value = (o.value+1); // note: our value is one more than the rhs.
        return *this;
    }    
};

int main(int argc, char *argv[])
{

    obj a("a", 1), b("b", 2), c("c", 3);

    a = b = c;
    cout << "a.value = " << a.value << endl;
    cout << "b.value = " << b.value << endl;
    cout << "c.value = " << c.value << endl;

    a = c;
    b = c;
    cout << "a.value = " << a.value << endl;
    cout << "b.value = " << b.value << endl;
    cout << "c.value = " << c.value << endl;

    return 0;
}

输出

b = c
a = b
a.value = 5
b.value = 4
c.value = 3
a = c
b = c
a.value = 4
b.value = 4
c.value = 3

关于c++ - typedef 结构中的重载运算符 (c++)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14047191/