昨晚学C++想到的一个问题。求教。

[I_code]

#include <iostream>
using namespace std;

class Widget
{
public:
	const Widget operator*(const Widget& w)
	{
		cout << "class Widget" << endl;
		return Widget();
	}
protected:
private:
};

const Widget operator*(const Widget& w)
{
	cout << "function Widget" << endl;
	return Widget();
}
int main()
{
	Widget a;
	Widget b;
	a * b; //为什么调用的是类里面的重载函数？
	return 0;
}

以上代码输出class widget。
为什么它们没有调用函数呢？感觉函数的作用范围更大一些...
如果每次都从类里面先找重载函数执行，那么把operator*写在类的外面是不是很没有意义？

[we_sky2008]

你定义的全局的operator*不是相乘，而是解引用
如果是想定义为全局的相乘时，需要两个参数

[ningto.com]

类里面才起作用

[I_code]

[Quote=引用 1 楼 we_sky2008 的回复:]
你定义的全局的operator*不是相乘，而是解引用
如果是想定义为全局的相乘时，需要两个参数
[/Quote]
如果我定义一个operator*全局相乘，那么C++是先从哪里开始找？找到一个可用的就行了么？

[bdmh]

class Widget
{
public:
	friend void operator*(const Widget& w,const Widget& y);
protected:
private:
};


void operator*(const Widget& w,const Widget& y)
{
	cout << "function Widget" << endl;
}

[Michael_Xie]

[Quote=引用 2 楼 tujiaw 的回复:]

类里面才起作用
[/Quote]

为什么？

[we_sky2008]

[Quote=引用 3 楼 i_code 的回复:]
引用 1 楼 we_sky2008 的回复:
你定义的全局的operator*不是相乘，而是解引用
如果是想定义为全局的相乘时，需要两个参数

如果我定义一个operator*全局相乘，那么C++是先从哪里开始找？找到一个可用的就行了么？
[/Quote]
有重载解析的，三步：候选、可行、最佳匹配

[Michael_Xie]

[Quote=引用 1 楼 we_sky2008 的回复:]

你定义的全局的operator*不是相乘，而是解引用
如果是想定义为全局的相乘时，需要两个参数
[/Quote]

定义全局的相乘时，两个参数，也是调用的class里的函数。
为什么？

[we_sky2008]

楼主可以如下试试：

#include <iostream>
using namespace std;

class Widget
{
public:
    Widget(){}
    const Widget operator*(const Widget& w)
    {
        cout << "class Widget" << endl;
        return Widget();
    }
protected:
private:
};

const Widget operator*(const Widget& w1, const Widget& w2)
{
    cout << "const Widget operator*(const Widget& w1, const Widget& w2)" << endl;
    return Widget();
}

const Widget operator*(Widget& w1, const Widget& w2)
{
    cout << "const Widget operator*(Widget& w1, const Widget& w2)" << endl;
    return Widget();
}

const Widget operator*(Widget& w1, Widget& w2)
{
    cout << "const Widget operator*(Widget& w1, Widget& w2)" << endl;
    return Widget();
}

int main()
{
    Widget a;
    Widget b;
    const Widget ca;
    const Widget cb;

    a * b;
    ca * cb;
    //a * ca;//二义
    ca * cb;
    
    system("pause");
    return 0;
}

[I_code]

[Quote=引用 7 楼 michael_xie 的回复:]
引用 1 楼 we_sky2008 的回复:

你定义的全局的operator*不是相乘，而是解引用
如果是想定义为全局的相乘时，需要两个参数


定义全局的相乘时，两个参数，也是调用的class里的函数。
为什么？
[/Quote]
我也想问，求更详细的解释。

[naturemickey]

#include <iostream>
using namespace std;

class Widget
{
public:
    const Widget operator*(const Widget& w)
    {
        cout << "class Widget" << endl;
        return Widget();
    }
protected:
private:
};

const Widget Widget::operator*(const Widget& w)
{
    cout << "function Widget" << endl;
    return Widget();
}
int main()
{
    Widget a;
    Widget b;
    a * b; //为什么调用的是类里面的重载函数？
    return 0;
}

[we_sky2008]

[Quote=引用 7 楼 michael_xie 的回复:]
引用 1 楼 we_sky2008 的回复:

你定义的全局的operator*不是相乘，而是解引用
如果是想定义为全局的相乘时，需要两个参数


定义全局的相乘时，两个参数，也是调用的class里的函数。
为什么？
[/Quote]
类成员操作符被调用时，调用者就是隐式的第一个参数，楼主还是看下书吧，
书上讲的很清楚的

[KWDIWT]

类外的那个只有一个形参.

类内有个附加的隐含形参this, 也就第一个操作数

[I_code]

[Quote=引用 8 楼 we_sky2008 的回复:]
楼主可以如下试试：

C/C++ code


#include <iostream>
using namespace std;

class Widget
{
public:
Widget(){}
const Widget operator*(const Widget& w)
{
cout << "class Widge……
[/Quote]
为什么 a * ca; 会产生二义

[Xomic]

在类内部重载运算符，如果你不声明为友元的话它就是类的成员函数，我们只有建立对象之后才能调用函

数（也有特殊情况），这个对象就是第一个操作数！

在类的外部，双目就必须有两个参数，单目就一个...

运算符重载不会改变其原有的优先级和性质！单目还是单目，双目还是双目！

[I_code]

经过楼上各位的指导，我已经想明白了。谢谢大家。

[至善者善之敌]

[Quote=引用 11 楼 we_sky2008 的回复:]
引用 7 楼 michael_xie 的回复:
引用 1 楼 we_sky2008 的回复:

你定义的全局的operator*不是相乘，而是解引用
如果是想定义为全局的相乘时，需要两个参数


定义全局的相乘时，两个参数，也是调用的class里的函数。
为什么？

类成员操作符被调用时，调用者就是隐式的第一个参数，楼主还是看下书吧，
书上讲的很清楚的
[/Quote]

++1
算数运算符重载的时候，在类中可以省去调用者本身这个参数

如果你要在类外定义的话，你需要定义两个参数了const Widget operator*(const Widget& w,Widget& y)
但你又不能在类里这样定义，因为编译器会报错，认为你的参数太多了

[tompaz]

a * b;
这个是怎么解释才编译的过去的？
不懂