1. 首先设计整型类:class Int
class Int
{
private:
int value;
public:
Int(int x = 0) :value(x)
{
cout << "Create Int:" << this << endl;
}
Int(const Int& it) :value(it.value)
{
cout << "copy Create Int:" << this << endl;
}
Int& operator = (const Int& it)
{
if (this != &it)
{
value = it.value;
}
cout << this << "=" << &it << endl;
return *this;
}
~Int()
{
cout << "Destory Int:" << this << endl;
}
};
普通指针
:如果申请堆区空间,在使用完,必须用delete或者new来将空间释放。
如下:
int main(void)
{
//正常指针,申请堆空间,必须用delete来释放
Int* ip = new Int(10);
delete ip;
return 0;
}
- 那怎么样,指针在申请完堆区空间,可以对空间进行自动释放呢?
我们通过设计一个类,将delete封装在类中的析构函数中,在我们使用完指针,就会跟随对象被析构掉。
2. 设计一个Object类,并设计Int
类型的指针。
//类声明的指针 Int *p;
class Object
{
Int* p; //p存放的其实就是Int的地址,*p就是Int本身
public:
Object(Int* s = NULL) :p(s)
{
cout << "create Object:" << endl;
}
~Object()
{
if (p != NULL)
{
delete p;
}
p = NULL;
cout << "destory Object:" << endl;
}
};
这样对p指针的管理就达到了,使用完,会自动调用析构函数释放,不需要手动的对其释放
那如何获取Int类型的值呢?
直接点Int中定义两个获取值的方法即可。
//普通方法
int& value() { return value; }
//常方法,只能读数据,不能对数据进行修改
const int& value()const { return value; }
由于在类Object中定义的是Int类型的指针变量,因此在访问类Int中的value,需要使用->和*运算符。
接下来我们就重载这两个运算符:
Int& operator*()
{
return *p;
}
const Int& operator*()const
{
return *p;
}
Int* operator->()
{
return &**this; //==p
}
const Int* operator->()const
{
return &**this; //==p
}
其中:
- p 是Int类类型,p存放的就是Int的地址,而p就是Int本身,所以对Object类型解引用就是Int本身,就可以通过()运算符访问Int的成员。
- &**this:this表示的是Obj,this就是obj本身,*this表示调用对象的operator(),该运算符返回的p,再取地址就是p本身,而p本身就是Int的地址。
这样我们就可以通过 Object obj(new Int(10));obj->value();来获取value的值。
如下:
int main(void)
{ //通过obj对象来管理 p指针
//new Int(10) 1.创建空间 2.调用Int的构造函数,将10传给x,对value进行初始化
Object obj(new Int(10));
//接下来调用Object中的构造函数,刷新Int *s中value 的值
//再将p刷新。
// cout << (*obj).getvalue() << endl; //然后创建obj对象,new一个空间
cout << obj->getvalue() << endl;
return 0;
}