运算符重载

[stringsl]

ct operator++();

ct ct::operator++()
{
++itsval; //主要
ct temp; //主要
temp.setitsval(itsval); //主要
return temp;  //主要

}

请问个问题，第一个operator ++这个是不是格式问题，好像在程序中起不到什么作用？该函数的执行主要在上面标有 //主要 部分吗 ？operator++是不是只是格式问题；/？？

[過於喧囂的孤獨]

mark下，与楼主一起期待答案~~~~~~~~~~~~~~

[Csuxiaowu]

代码 多贴些

[we_sky2008]

楼主要分清前置++和后置++，要是我我会这么实现这两个操作符

ct &operator++();//前置++
constct operator++(int);//后置++

ct &ct::operator++()
{
    ++itsval;
    return *this;
}
const ct ct::operator++(int)
{
    ct temp = *this;
    ++*this;
    return temp;
}

[qq120848369]

ct& ct::operator++()
{
   ++itsval; 
   return *this;
}

ct ct::operator++(int)
{
   ct temp(*this);
   ++itsval; 
   return temp;
}

[qq120848369]

没必要返回const ct,会影响后面的操作只能使用const成员,这里的右值语义是由用户自己掌握的.

[xxphddz]

ct& ct::operator++()
{
++itsval; //主要
return *this; //主要

}

[we_sky2008]

[Quote=引用 6 楼 qq120848369 的回复:]
没必要返回const ct,会影响后面的操作只能使用const成员,这里的右值语义是由用户自己掌握的.
[/Quote]
请参考《More Effective C++》Item M6

[qq120848369]

[Quote=引用 7 楼 we_sky2008 的回复:]
引用 6 楼 qq120848369 的回复:
没必要返回const ct,会影响后面的操作只能使用const成员,这里的右值语义是由用户自己掌握的.

请参考《More Effective C++》Item M6
[/Quote]

请参考C++ primer 446

[we_sky2008]

[Quote=引用 6 楼 qq120848369 的回复:]
没必要返回const ct,会影响后面的操作只能使用const成员,这里的右值语义是由用户自己掌握的.
[/Quote]
以下引自《More Effective C++》Item M6：
“很明显一个后缀increment必须返回一个对象（它返回的是增加前的值），但是为什么是const对象呢？假设不是const对象，下面的代码就是正确的：

UPInt i;

i++++; // 两次increment后缀

这组代码与下面的代码相同：

i.operator++(0).operator++(0);

很明显，第一个调用的operator++函数返回的对象调用了第二个operator++函数。

有两个理由导致我们应该厌恶上述这种做法，第一是与内置类型行为不一致。当设计一个类遇到问题时，一个好的准则是使该类的行为与int类型一致。而int类型不允许连续进行两次后缀increment：

”

[we_sky2008]

[Quote=引用 8 楼 qq120848369 的回复:]
引用 7 楼 we_sky2008 的回复:
引用 6 楼 qq120848369 的回复:
没必要返回const ct,会影响后面的操作只能使用const成员,这里的右值语义是由用户自己掌握的.

请参考《More Effective C++》Item M6


请参考C++ primer 446
[/Quote]
哈哈，第几版的？

[liutengfeigo]

找本好点的教材学吧。c++ primer

[qq120848369]

四版的,我是觉得不应该const,但是为了避免用户拿来当左值又应该const,但是又免不了*(iter++)=2;
这样的迭代器操作,所以我看还是就事论事,看情况来写吧.

#include <iostream>
using namespace std;

class Iter
{
public:
	Iter(int *q):p(q)
	{
	}

	Iter(const Iter &obj)
	{
		*this=obj;
	}

	Iter& operator =(const Iter &obj)
	{
		p=const_cast<int*>(obj.p);
		return *this;
	}

	int& operator *() // 同时实现非const
	{
		return *p;
	}

	const int& operator *() const //与const版的所有函数,那样比较好
	{
		return *p;
	}

	Iter& operator ++()
	{
		p++;
		return *this;
	}

	const Iter operator ++(int)
	{
		Iter temp(*this);
		++(*this);
		return temp;
	}

private:
	int *p;
};

int main()
{
	int arr[2]={1,2};

	Iter a(arr);
	Iter b(arr);

	if( *(a++) == (*b) )  
	{
		cout<<"相等"<<endl;
	}
	

	return 0;
}

[we_sky2008]

[Quote=引用 12 楼 qq120848369 的回复:]
四版的,我是觉得不应该const,但是为了避免用户拿来当左值又应该const,但是又免不了*(iter++)=2;
这样的迭代器操作,所以我看还是就事论事,看情况来写吧.


C/C++ code
#include <iostream>
using namespace std;

class Iter
{
public:
Iter(int *q):p(q)
……
[/Quote]
恩，要看实际应用来决定的，但我个人还是喜欢加上const
你刚才举的例子中
*(iter++)=2;这句，我觉得即使iter++返回一个const迭代器，赋值也是可以进行的(当然这里可能需要将重载的operator*操作符函数设置为const成员函数)，
就像我们对一个const指针解引用然后赋值，这在语义上是完全合法的，如：
int i = 123;
int *const cp = &i;//cp为指针常量
*cp = 456;

[qq120848369]

[Quote=引用 13 楼 we_sky2008 的回复:]
引用 12 楼 qq120848369 的回复:
四版的,我是觉得不应该const,但是为了避免用户拿来当左值又应该const,但是又免不了*(iter++)=2;
这样的迭代器操作,所以我看还是就事论事,看情况来写吧.


C/C++ code
#include <iostream>
using namespace std;

class Iter
{
public:
I……
[/Quote]

我例子没举好,感觉不好举.

反正总结一下就是,如果能漂亮的实现构造,拷贝构造,赋值,每个成员函数都有对应const版本的话,加上const是完美的.

[qq120848369]

[Quote=引用 13 楼 we_sky2008 的回复:]
引用 12 楼 qq120848369 的回复:
四版的,我是觉得不应该const,但是为了避免用户拿来当左值又应该const,但是又免不了*(iter++)=2;
这样的迭代器操作,所以我看还是就事论事,看情况来写吧.


C/C++ code
#include <iostream>
using namespace std;

class Iter
{
public:
I……
[/Quote]

你说的有道理,const iter的确可以修改*p,
int& operator *() const
{
return *p;
}

这样虽然矛盾,但也是符合语法的.

[we_sky2008]

[Quote=引用 15 楼 qq120848369 的回复:]
引用 13 楼 we_sky2008 的回复:
引用 12 楼 qq120848369 的回复:
四版的,我是觉得不应该const,但是为了避免用户拿来当左值又应该const,但是又免不了*(iter++)=2;
这样的迭代器操作,所以我看还是就事论事,看情况来写吧.


C/C++ code
#include <iostream>
using namespace std;

……
[/Quote]
恩，其实知道是怎么回事就行了
呵呵