MATLAB 数组支持矩阵运算和元素运算。例如，M*N 和 M.*N。这是区分两种不同操作的一种非常直观的方法。如果我想在 C++ 中实现类似的操作，我该怎么做？
我也可以创建一个新的运算符.* 吗？如果是的话，谁能给我一些指导？
【问题讨论】：
*？或者您想创建一个具有不同符号的运算符？
标签： c++
不，很遗憾，您不能定义新的运算符——您只能重载现有的运算符（有一些重要的例外，例如operator.）。即使这样，对于给定运算符具有非常清晰且无争议的现有语义的类型，重载运算符通常也是一个好主意——例如，任何表现为数字的类型都是重载算术和比较运算符的良好候选者，但是你应该确保operator+ 不会，比如说，减去两个数字。
【讨论】：
这就像定义一个名为（在本例中）operator*() 的函数一样简单（也同样困难！）：
Matrix operator*(const Matrix &m1, const Matrix &m2) ...
其中Matrix 是您定义的用于表示矩阵的类。
【讨论】：
不，你不能超载op.*：
[C++03 & C++11: 13.5/3]:以下运算符不能重载：. .* :: ?:
【讨论】：
sizeof()和typeid()
op.* 不能重载的单个段落，因为这就是 OP 所要求的。
您不能重载.*（参见Lightness' answer 以了解标准文本），但是，有趣的是，您可以重载->*（类似于重载-> 但不能重载@ 987654325@)。如果这足以区分，那就去吧：
struct Int {
int i;
Int operator*(Int rhs) const { return Int{i * rhs.i}; }
Int operator->*(Int rhs) const { return Int{i + rhs.i}; }
friend std::ostream& operator<<(std::ostream& os, Int rhs) {
return os << "Int(" << rhs.i << ')';
}
};
int main() {
Int five{5};
Int six{6};
std::cout << (five * six) << ", " << (five ->* six) << '\n';
}
这将打印Int(30), Int(11)。
【讨论】：
.*，但无论如何都是好的答案。
MATLAB 数组支持矩阵运算和元素运算。例如，M*N 和 M.*N。这是区分这两种不同操作的一种非常直观的方法。如果我想在 C++ 中实现类似的操作，我该怎么做？
我也可以创建一个新的运算符 .* 吗？如果是的话，谁能给我一些指导？
至于第一部分，您可以重载大多数运算符，有些则不能重载，C++ 中的运算符列表如下：
算术
+ (addition)- (subtraction)* (multiplication)/ (division)% (modulus)按位
^ (XOR)| (OR)& (AND)~ (Complement)<< (Shift Left, Insertion to Stream)>> (Shift Right, Extraction from Stream)作业
= (Assignment)关系
== (Equality)!= (Inequality)> (Greater-Than)< (Less-Than)>= (Greater-Than Or Equal-To)<= (Less-Than Or Equal-To)逻辑
! (NOT)&& (AND)|| (OR)复合赋值
+= (Addition-Assignment)-= (Subtraction-Assignment)*= (Multiplication-Assignment)/= (Division-Assignment)%= (Modulus-Assignment)&= (AND-Assignment)|= (OR-Assignment)^= (XOR-Assignment)<<= (Shift-Left Assignment)>>= (Shift-Right Assignment)增量 - 减量 - 都有两种形式（前缀）和（后缀）
++ (Increment)-- (Decrement)下标
[] (Subscript)函数调用
() (Function Call)地址、引用、指针
operator&()operator*()operator->()逗号
operator,()会员参考
operator->()operator->*()内存管理
newdeletenew[]delete[]转化
operator "type" () constNON Modifiable Operators - 不能重载的运算符
?: (Conditional - Ternary). (Member Selection).* (Member Selection With Pointer To Member):: (Scope Resolution)sizeof() (Object Size Information)typeid() (Object Type Information)因此，了解此列表将有助于回答您的问题。你能在 C++ 中创建一个“新运算符”吗？不！如果你想在 C++ 中实现类似的操作；我该怎么做？
您有 4 种选择：重载一个已经存在且可以重载的运算符，编写一个函数或方法来执行您想要执行的计算类型，创建一个模板类型来为您完成工作，或者最后一个这是最不常见的做法，但您也可以编写宏来为您执行这些操作。
有一个只有标头的数学 API 库，它经常与 OpenGL 图形 API 和 OpenGL 的着色器语言 GLSL 一起使用，并且该库具有许多可用于矢量、矩阵、四元数等的功能，以及所有必要的函数和操作可以对他们做。这是指向GLM 的链接，您可以查看他们的文档以及他们的库实现，因为它是一个只有标头的库或 API。这应该让您了解他们如何构建 Vector 和 Matrix 对象以及可以对它们执行的操作。
【讨论】：
在 C++ 中，有一系列预定义的运算符，其中大部分是可重载的（.* 不是）。此外，any 名称可以用作运算符，例如：
#include <iostream>
// generic LHSlt holder
template<typename LHS, typename OP>
struct LHSlt {
LHS lhs_;
};
// declare myop as an operator-like construct
enum { myop };
// parse 'lhs <myop' into LHSlt
template<typename LHS>
LHSlt<LHS, decltype(myop)> operator<(const LHS& lhs, decltype(myop))
{
return { lhs };
}
// declare (int <myop> int) -> int
int operator>(LHSlt<int, decltype(myop)> lhsof, int rhs)
{
int& lhs = lhsof.lhs_;
// here comes your actual implementation
return (lhs + rhs) * (lhs - rhs);
}
// strictly optional
#define MYOP <myop>
int main() {
std::cout << (5 <myop> 2) << ' ' << (5 MYOP 2);
}
免责声明：严格来说，这被翻译为(5 < myop) > 2，即LHSlt<int, decltype(myop)>(5) > 2。因此，在 C++ 术语中，它不是一个新的“运算符”，但它的使用方式完全相同，即使在 ADL 方面也是如此。此外，如果类型很大，您可能希望存储const T&。
请注意，您可以使用任何可以在类外部定义的二元运算符来执行此操作；优先级基于两侧的优先级（< 和 >）。因此，您可以拥有例如*myop*、+myop+、<<myop>>、<myop>、|myop| 按优先顺序排列。
如果你想要右关联，它会变得有点棘手。您将需要 RHS 持有者和 LHS 持有者（后者在此处为 LHSlt）并使用周围的运算符，以使右侧的优先级高于左侧的优先级，例如a |myop> b |myop>c 是 a |myop> (b |myop> c)。然后你需要你的类型和你的持有人类型的函数作为 lhs。
【讨论】：
正如其他答案所说，重载operator.* 是不可能的。
但我为您的问题找到了一个很好的解决方案，请查看here。
您可以提供 operator-ish 形式的任何方法，例如：
M <matrix_mul> N
【讨论】：
顺便说一句：我正在寻求回答这个问题的部分内容。我也不寻求在其他有价值的答案中复制所有信息。赏金寻求与所问问题不同的东西，所以我没有回应。
提供矩阵乘法实际上相当简单。由于我不打算描述数据结构来表示矩阵并完全实现对它们的操作和有效性检查，因此我将仅提供框架来说明。
示例 1：operator*() 作为成员函数
class M // a basic matrix class
{
public:
// assume other constructors and members to set things up
M operator*(const M &rhs) const;
};
M M::operator*(const M &rhs) const
{
// implement checks on dimensions, throw an exception if invalid
M result;
// implement the multiplication (typical iterations) and store results in result
return result;
}
int main()
{
M a;
M b;
// set up elements of a and b as needed
M c = a*b; // this relies on M having appropriate constructor(s) to copy or move the result of a*b into c
M d;
d = a * b; // this relies on M having appropriate operator=() to assign d to the result of a*b
}
上面实现了operator*()作为成员函数。所以，在功能上，c = a*b 等价于c = a.operator*(b)。 const 限定符表示矩阵乘法 a*b 通常不会更改 a 或 b。
示例 2：operator*() 作为非成员函数
现在，operator*() 也可以实现为非成员（可选friend），其骨架看起来像
class M // our basic matrix class, different operator *
{
public:
// assume other constructors and members to set things up
friend M operator*(const M &lhs, const M &rhs);
};
M operator*(const M &lhs, const M &rhs)
{
// implement checks on dimensions, throw an exception if invalid
M result;
// implement the multiplication (typical iterations) and store results in result
return result;
}
// same main() as before
请注意，在这种情况下，a*b 现在等同于 operator*(a, b)。
如果您想同时使用这两种形式，则需要注意避免歧义。如果提供了operator*() 的两种形式，则它们在c = a*b 之类的语句中都是有效匹配项，并且编译器无法选择一种形式而不是另一种形式。结果是代码无法编译。
示例 3：重载operator*()
还可以重载operator*() - 例如，将矩阵乘以标量。
class M // a basic matrix class
{
public:
// assume other constructors and members to set things up
M operator*(const M &rhs) const; // as in first example
M operator*(double scalar) const; // member form
friend M operator*(double scalar, const M &rhs); // non-member form
};
M M::operator*(double scalar) const
{
M result;
// implement the multiplication (typical iterations) and store results in result
return result;
}
M operator*(double scalar, const M &m)
{
M result;
// implement the multiplication (typical iterations) and store results in result
return result;
}
int main()
{
M a;
M b;
// set up elements of a and b as needed
M c = b * 2.0; // uses the member form of operator*() above
M d;
d = 2.0*a; // uses the non-member form of operator*() above
}
以上b*2.0相当于b.operator*(2.0)的调用和2.0*a非会员operator*(2.0, a)的调用。成员形式通常只能用于左侧操作数为M 类型的表达式。因此，如果只提供operator*() 的成员形式，2.0*a 将不起作用。
讨论
除了对上述歧义的担忧之外，在重载运算符时还需要注意其他事项。
a+b*c 中，* 的优先级总是高于+。这也是在 C++ 中重载 ^ 以进行幂运算不是一个好主意的原因，因为 ^ 在 C++ 中的优先级低于 +（作为整数类型的按位运算）。因此，a + b^c 在 C++ 中实际上等同于 (a + b)^c，而不是 a + (b^c)（任何具有代数基础知识的人都会想到）。**，因此a ** b 将a 提升到b 的幂（其他语言可以做到），并且不可能创建一个。在 C++ 中不能重载的运算符之一是 .*。所以不可能像在 Matlab 中那样使用这样的运算符。我通常建议不要尝试使用其他运算符获得相同的效果，因为上述约束会影响这一点（并导致表达式给出违反直觉的行为）。相反，只需提供另一个命名函数来完成这项工作。比如作为成员函数
class M
{
public:
// other stuff
M ElementWiseProduct(const M &) const;
};
【讨论】：
大多数答案已经涵盖了哪些运算符是可重载的和不可重载的，但没有人讨论为什么有些是可变的而有些不是。
以下是我在this stackoverflow answer 中找到的 Bjarne Stroustrup（编写 c++ 的人）的一句话。特别注意第三段。
当我决定允许 operator-> 重载时，我自然会考虑是否 operator .可以类似地重载。
当时，我认为以下论点是决定性的：如果 obj 是一个类对象，那么 obj.m 对该对象类的每个成员 m 都有意义。我们尽量不通过重新定义内置操作来使语言可变（尽管出于迫切需要的 = 和一元 & 违反了该规则）。
如果我们允许重载 .对于 X 类，我们将无法通过正常方式访问 X 的成员；我们必须使用指针和 ->，但 -> 和 & 也可能被重新定义。我想要一种可扩展的语言，而不是可变的。
这些论点很有分量，但不是结论性的。特别是在 1990 年，Jim Adcock 提议允许 operator 重载。正是 operator -> 的方式。
A page on his website 补充一点：
我可以定义自己的运算符吗？
对不起，没有。这种可能性已被多次考虑，但每次我/我们都认为可能出现的问题超过了可能带来的好处。
这不是语言技术问题。甚至当我在 1983 年第一次考虑它时，我就知道如何实现它。然而，我的经验是，当我们超越最琐碎的例子时，人们似乎对运算符使用的“明显”含义有微妙的不同看法。一个经典的例子是 a ** b ** c。假设 ** 表示取幂。现在 a ** b ** c 应该表示 (a ** b) ** c 还是 a ** (b ** c)？我认为答案是显而易见的，我的朋友们也同意了——然后我们发现我们没有就哪个决议是显而易见的达成一致。我的猜测是这样的问题会导致细微的错误。
因此，尽管大多数运算符都可以重载，但人们从未打算在 c++ 中创建任意运算符。
【讨论】：