我想打一个typedef结构称为pos （从位置）存储坐标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;
}
即使在这里，这是没有必要的。 默认拷贝赋值运算符将做上面为您免费的（和代码！活泉！）
注意 ：有当上应该有利于复制/交换成语来避免倍。 虽然不需要这种特殊情况下，它可能是这样的：
pos& operator=(pos a) // by-value param invokes class copy-ctor
{
this->swap(a);
return *this;
}
然后交换方法实现的：
void pos::swap(pos& obj)
{
// TODO: swap object guts with obj
}
你这样做利用类拷贝构造函数进行复印，然后利用异常安全的交换来进行交流。 其结果是进入副本离开（和销毁）你的对象的老胆量，而你的对象假定的有所有权。 更多的复制/交换这里的成语 ，与利弊其中一起。
在适当的时候通过const引用传递对象
您所有的输入参数，您的所有成员目前都使得无论是在调用被传递的副本。 虽然它可能是平凡的这样的代码，它可以是对于较大的对象类型非常昂贵。 一个exampleis这里给出：
更改此：
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 =()明确修改本地对象，因此，运营商不应该是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);
}
};
编辑 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
取而代之的typedef struct { ... } pos; 你应该做struct pos { ... }; 。 这里的问题是，你正在使用的pos被定义之前，类型名称。 通过移动名称结构定义的顶部，您可以使用结构定义本身这个名字。
此外， typedef struct { ... } name; 图案是C主义，并没有什么太大的地方在C ++中。
要回答你的问题关于inline ，有在这种情况下没有区别。 当一个方法是在结构/类定义中所定义，它是隐式联声明。 当你明确指定inline ，编译器有效地忽略它，因为该方法已声明为内联。
（ inline如果同样的方法在多个目标文件中定义的方法不会触发链接错误，链接器将简单地忽略所有，但他们中的一个，假设他们都是同一实现这与在线行为的唯一保证的变化。 。方法如今，只要不影响编译器的决定，关于是否内联函数，它们只是便于制作功能的实现在所有的翻译单位供选择，这使编译器选项内联函数，如果决定将是有益这样做的。）
试试这个：
struct Pos{
int x;
int y;
inline Pos& operator=(const Pos& other){
x=other.x;
y=other.y;
return *this;
}
inline Pos operator+(const Pos& other) const {
Pos res {x+other.x,y+other.y};
return res;
}
const inline bool operator==(const Pos& other) const {
return (x==other.x and y == other.y);
}
};
