C++中的对象指针

指向对象的指针

在建立对象的时候，变异系统会给每一个对象分配一定的存储空间，以存放其成员。

对象空间的起始地址就是对象的指针。可以定义一个指针变量，用来存放对象的指针。

一个简单的示例1.1：

#include<iostream>
using namespace std;
class Student
{
	public:
		int num;
		int score;
		Student(int ,int );//声明构造函数
		void Print();//声明输出信息函数
};
Student::Student(int n,int s)
{
	num=n;
	score=s;
}
void Student::Print(){
	cout<<num<<"\t"<<score<<endl;
}
int main(){
	Student stud(1,100);//实例化一个对象
	Student *p=&stud;//定义一个指向对象的指针，并使用对象stud的地址初始化
	cout<<"*p.num:"<<(*p).num<<endl;//使用指向对象的指针调用数据成员的方式一
	cout<<"p->score:"<<p->score<<endl;//使用指向对象的指针调用数据成员的方式二
	(*p).Print();
	p->Print();
	return 0;
}

指向对象成员的指针

对象有地址，存放对象初始地址的指针变量就是 指向对象的指针变量。

对象中的成员也有地址，存放对象成员地址的指针变量就是 指向对象成员的指针变量。

1.指向对象数据成员的指针

定义指向对象数据成员的方法和定义指向普通变量的方法相同：

数据类型    *    指针变量名

p=&t1.hour;//将对象t1的数据成员hour的地址赋给p,p指向t1.hour
cout<<*p<<endl;//输出t1.hour的值

2.指向对象成员函数的指针

定义指向成员函数的指针和定义指向普通函数的指针的方法是不同的。

定义指向普通函数的指针的方法是这样的：

数据类型名（* 指针变量名）（参数列表）；

如：

void  (*p)(int n,int m);//p是指向void型函数的指针变量
p=fun;//将fun函数的入口地址赋给指针变量p，p就指向了函数fun
(*p)(a,b);//调用fun函数，其中，a,b是实参

而定义一个指向对象成员函数的指针变量则比较复杂一些。

如果我们直接按照上面的方法定义指针变量，将对象成员函数名赋给指针变量p：

void (*p)();         
p=t1.Print();

编译会出现错误
成员函数与普通函数的一个最根本区别：它是类中的一个成员。

编译系统要求上面的复制语句中，指针变量的类型必须与赋值号右侧函数的类型相匹配，要求在一下3个方面要匹配：

1.函数参数的类型和参数个数

2.函数返回值的类型

3.所属的类

前两个是匹配的，而第三点不匹配。

指针变量p与类无关，而Print()却属于Student类。

要 定义指向成员函数的指针变量应该采用以下形式：

void (Student::*p)();//定义p为指向Student类中公共成员函数的指针变量

数据类型名（类名::*指针变量名）（参数表列）;

我们知道，所有的Student类实例化得到的对象都是公用一个成员函数的，所以我们没有必要指定它是指向那个对象的成员函数的指针，我们只需要定义它是指向该类的成员函数就可以了。

使 指针变量指向一个公用成员函数的一般形式为：

p=&Student::Print;

指针变量名=&类名::成员函数名;

在使用时，仍然需要将指针放到具体的对象中使用，(*p)的作用等价于Print()

stud.(*p);//作用与stud.Print()的作用等价

=================一个使用对象指针的例子1.2===========

#include<iostream>
using namespace std;
class Student
{
	public:
		int num;
		int score;
		Student(int ,int );
		void Print();
};
Student::Student(int n,int s)
{
	num=n;
	score=s;
}
void Student::Print(){
	cout<<num<<"\t"<<score<<endl;
}
int main(){
	Student stud(1,100);
	cout<<"stud.Print()"<<endl; 
        stud.Print();//直接调用对象stud的成员函数Print();
	Student *p_class=&stud;//定义指向对象stud的指针;
	cout<<"p_class->Print()"<<endl;
	p_class->Print();//通过指向对象的指针调用成员函数Print(); 
	void (Student::*p_fun)();//声明p_fun是指向Student中的函数的指针 
	p_fun=&Student::Print;//是p_fun指向Student类公用成员函数Print() 
	cout<<"(stud.*p_fun)()"<<endl;
	(stud.*p_fun)();//调用对象stud中的p_fun所指向的成员函数（即：stud.Print） 
	return 0;
}

this指针

每个对象中的数据成员都分别占用存储空间，如果对同一个类定义了n个对象，则有n组同样大小的空间一存放n个对象中的数据成员。

单数不同的对象都调用同一段函数代码段。

那么，当不同对象的成员函数引用数据成员时，怎么能保证引用的是所制定的对象的数据成员呢？

实际上，在每一个成员函数中，都包含一个特殊的指针，这个指针的名字是固定的，称为this指针。

它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。

例如：

Print()函数中

	cout<<num<<"\t"<<score<<endl;

实际上是

	cout<<this->num<<"\t"<<this->score<<endl;

this指针式隐式使用的，它是作为参数被传递给成员函数。

在程序中的函数：

void Student::Print(){
	cout<<num<<"\t"<<score<<endl;
}

C++编译系统会自动处理成：

void Student::Print(Student *this){
	cout<<this->num<<"\t"<<this->score<<endl;
}

即在成员函数的形参表列中增加一个this指针。在调用成员函数stud.Print()时，实际上是用以下方式调用的：

stud.Print(&stud);