C++ C+中的重载运算符*+；

我想通过以下方式重载运算符*：

#include <iostream>
using namespace std;

class A{
    public:
        double liczba;

    A operator * (int a){
        A b;
        b.liczba = this->liczba * a;
        return b;
    }
};


int main(){
    A a;
    2*a;
    return 0;
}

#包括
使用名称空间std；
甲级{
公众：
双李茨巴；
A运算符*（int A）{
A b；
b、 liczba=this->liczba*a；
返回b；
}
};
int main（）{
A A；
2*a；
返回0；
}

---

我有错误，我知道a*2不会导致问题，但如何执行2*a？

您需要声明一个朋友操作符：

class A{
    public:
        double liczba;

    A operator * (int a){
        A b;
        b.liczba = this->liczba * a;
        return b;
    }

    friend A operator*(int a, A & b);// friend operator
};

A operator*(int a, A & b)
{
    return b * a;
}

---

理想情况下，

A&b

将是

const A&b

，但您需要将已定义的运算符声明为

const

。

您需要声明一个朋友运算符：

class A{
    public:
        double liczba;

    A operator * (int a){
        A b;
        b.liczba = this->liczba * a;
        return b;
    }

    friend A operator*(int a, A & b);// friend operator
};

A operator*(int a, A & b)
{
    return b * a;
}

---

理想情况下，

A&b

将是

const A&b

，但您需要将已定义的运算符声明为

const

。

您需要声明一个朋友运算符：

class A{
    public:
        double liczba;

    A operator * (int a){
        A b;
        b.liczba = this->liczba * a;
        return b;
    }

    friend A operator*(int a, A & b);// friend operator
};

A operator*(int a, A & b)
{
    return b * a;
}

---

理想情况下，

A&b

将是

const A&b

，但您需要将已定义的运算符声明为

const

。

您需要声明一个朋友运算符：

class A{
    public:
        double liczba;

    A operator * (int a){
        A b;
        b.liczba = this->liczba * a;
        return b;
    }

    friend A operator*(int a, A & b);// friend operator
};

A operator*(int a, A & b)
{
    return b * a;
}

---

理想情况下，

A&b

将是

const A&b

，但您需要将已定义的运算符声明为

const

。

您应该将运算符声明为非成员函数。比如说

A operator * ( const A &a, int x )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

A operator * ( int x, const A &a )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

这是一个演示程序

#include <iostream>

class A{
    public:
        double liczba;
};


A operator * ( const A &a, int x )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

A operator * ( int x, const A &a )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

int main() 
{
    A a = { 10 };

    A b = 2 * a * 5;

    std::cout << b.liczba << std::endl;

    return 0;
}

---

您应该将运算符声明为非成员函数。比如说

A operator * ( const A &a, int x )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

A operator * ( int x, const A &a )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

这是一个演示程序

#include <iostream>

class A{
    public:
        double liczba;
};


A operator * ( const A &a, int x )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

A operator * ( int x, const A &a )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

int main() 
{
    A a = { 10 };

    A b = 2 * a * 5;

    std::cout << b.liczba << std::endl;

    return 0;
}

---

您应该将运算符声明为非成员函数。比如说

A operator * ( const A &a, int x )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

A operator * ( int x, const A &a )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

这是一个演示程序

#include <iostream>

class A{
    public:
        double liczba;
};


A operator * ( const A &a, int x )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

A operator * ( int x, const A &a )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

int main() 
{
    A a = { 10 };

    A b = 2 * a * 5;

    std::cout << b.liczba << std::endl;

    return 0;
}

---

您应该将运算符声明为非成员函数。比如说

A operator * ( const A &a, int x )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

A operator * ( int x, const A &a )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

这是一个演示程序

#include <iostream>

class A{
    public:
        double liczba;
};


A operator * ( const A &a, int x )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

A operator * ( int x, const A &a )
{
    A b;
    b.liczba =  a.liczba * x;
    return b;
}

int main() 
{
    A a = { 10 };

    A b = 2 * a * 5;

    std::cout << b.liczba << std::endl;

    return 0;
}

---

您可以声明非成员函数：

A operator*( int i, const A & a ) {
    A b;
    b.liczba = a.liczba * i;

    return b;
}

---

下面是一个。

您可以声明一个非成员函数：

A operator*( int i, const A & a ) {
    A b;
    b.liczba = a.liczba * i;

    return b;
}

---

下面是一个。

您可以声明一个非成员函数：

A operator*( int i, const A & a ) {
    A b;
    b.liczba = a.liczba * i;

    return b;
}

---

下面是一个。

您可以声明一个非成员函数：

A operator*( int i, const A & a ) {
    A b;
    b.liczba = a.liczba * i;

    return b;
}

---

这是一个。

什么错误？请具体说明。您定义的唯一运算符左侧为A参考，右侧为

int

值，即

A*int

。如果您希望反向允许

int*A

，请定义一个自由函数运算符。有什么错误？请具体说明。您定义的唯一运算符左侧为A参考，右侧为

int

值，即

A*int

。如果您希望反向允许

int*A

，请定义一个自由函数运算符。有什么错误？请具体说明。您定义的唯一运算符左侧为A参考，右侧为

int

值，即

A*int

。如果您希望反向允许

int*A

，请定义一个自由函数运算符。有什么错误？请具体说明。您定义的唯一运算符左侧为A参考，右侧为

int

值，即

A*int

。如果您希望反向允许

int*A

，请定义一个自由函数运算符。