C++ 使用用户定义的操作隐式转换为类型

我想对类中的类型使用用户定义的运算符：

class TWithUserDefinedOp
{
private: int a{42};
public: operator *(const TWithUserDefinedOp& other) { return a * other.a;}
};

class Wrap 
{
private: TWithUserDefinedOp a;
public: operator TWithUserDefinedOp() const { return a; }
}

现在，当我想要多个

包装

类时，我希望它能工作

Wrap a, b;
auto mul = a * b; //Error: Wrap does not define this operator or a conversion to a type acceptable to the predefined operator

现在，如果我更改换行以保持整型：

 class WrapIntegral 
 {
 private: int a{42};
 public: operator int() const { return a; }
 }

乘法现在起作用了

WrapIntergal a,b;
auto mulInt = a * b; // this works ok

---

我在其他类似的问题中读到，

C++

只允许1级隐式转换。如果我计算正确，在第一个示例中只有一个隐式转换。从

Wrap

到

TWithUserDefinedOp

，为其定义了

运算符*

。我的误解是什么？我做错了什么

我认为问题在于您需要将类类型转换为整数类型，这是乘法运算符的预定义类型。在第一个示例中，您没有它。

op*具有签名：TwithUserDefinedOperator*（const TwithUserDefinedOperator&other）。包装类也一样

这意味着第一个转换是（Wrap->TWithUserDefinedOp），第二个转换是（TWithUserDefinedOp->Wrap）

原始代码的可能修复程序：

#include <iostream>
#include <typeinfo>

using namespace std;

class TWithUserDefinedOp
{
private:
    int a{ 42 };
public:
    TWithUserDefinedOp(int a_ = 1) : a(a_) {}
    friend TWithUserDefinedOp operator* (const TWithUserDefinedOp& a, const TWithUserDefinedOp& b);
};

TWithUserDefinedOp operator* (const TWithUserDefinedOp& a, const TWithUserDefinedOp& b)
{
    return TWithUserDefinedOp(a.a * b.a);
}

class Wrap
{
private:
    TWithUserDefinedOp a;
public:
    Wrap(const TWithUserDefinedOp& a_ = TWithUserDefinedOp()) : a(a_) {}
    operator TWithUserDefinedOp() const
    {
        return a;
    }
};

int main()
{
    Wrap a, b;    
    auto c = a * b;
    cout << typeid(c).name() << "\n";   // TWithUserDefinedOp
    Wrap d = a * b;
    return 0;
}

#包括
#包括
使用名称空间std；
类TWithUserDefinedOp
{
私人：
int a{42}；
公众：
TWithUserDefinedOp（inta_uu=1）：a（a_u）{
friend TwithUserDefinedOperator*（常数TWithUserDefinedOp&a，常数TWithUserDefinedOp&b）；
};
TwithUserDefinedOperator*（常数TWithUserDefinedOp&a，常数TWithUserDefinedOp&b）
{
返回两个已定义的顶点（a.a*b.a）；
}
类包装
{
私人：
两次定义为a；
公众：
Wrap（const TWithUserDefinedOp&a_u=TWithUserDefinedOp（））：a（a_u）{
运算符TWithUserDefinedOp（）常量
{
返回a；
}
};
int main（）
{
包裹a、b；
自动c=a*b；
我可以为它定义乘法运算符吗？这应该足够了。它涉及到内部乘法整数类型。您已经为TWithUserDefinedOp定义了乘法运算符，而不是为Wrap定义了乘法运算符