&>&C++对象和指针的引用
C++对象和指针的引用
上传大小：5KB
指向类的成员的指针
在C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
&类型说明符&&类名&::*&指针名&
指向成员函数的指针格式如下：
&类型说明符&(&类名&::*&指针名&)(&参数表&)
例如，设有如下一个类A：
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::
由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后
，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符-&*。例如：
A *p = &a;
//a是类A的一个对象，p是指向对象a的指针。
p -&* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
&类型说明符&*&指向函数指针名&(&参数表&)
关于给指向函数的指针赋值的格式如下：
&指向函数的指针名&=&函数名&
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*&指向函数的指针名&)(&实参表&)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include &iostream.h&
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
void main()
//定义类A的一个对象x
//定义一个指向类数据成员的指针pc
//给指针pc赋值
//用指针方式给类成员c赋值为3
int (A::*pfun)(int);
//定义一个指向类成员函数的指针pfun
//给指针pfun赋值
//定义一个对象指针p，并赋初值为x
cout&&(p-&*pfun)(5)&&
//用对象指针调用指向类成员函数指针pfun指向的函数
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout&&x&&&,&&&y&& }
void M::copy(M *m)
void fun(M m1, M *m2);
void main()
M p(5, 7),
q.copy(&p);
fun(p, &q);
p.print();
q.print();
void fun(M m1, M *m2)
m1.setxy(12, 15);
m2-&setxy(22,25);
输出结果为：
从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2-&setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout&&x&&&,&&&y&& }
void M::copy(M &m)
void fun(M m1, M &m2;);
void main()
M p(5, 7),
q.copy(p);
fun(p, q);
p.print();
q.print();
void fun(M m1, M &m2;)
m1.setxy(12, 15);
m2.setxy(22, 25);
该例子与上面的例子输出相同的结果，只是调用时的参数不一样。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include &iostream.h&
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &);
//对象引用作函数参数
void print() {cout&&a&&&,&&&b&& }
void A::copy(A &)
if (this == &)
//这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
//*this是操作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
void main()
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
运行结果：
指向类的成员的指针
在C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
&类型说明符&&类名&::*&指针名&
指向成员函数的指针格式如下：
&类型说明符&(&类名&::*&指针名&)(&参数表&)
例如，设有如下一个类A：
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::
由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符-&*。例如：
A *p = &a;
//a是类A的一个对象，p是指向对象a的指针。
p -&* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
&类型说明符&*&指向函数指针名&(&参数表&)
关于给指向函数的指针赋值的格式如下：
&指向函数的指针名&=&函数名&
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*&指向函数的指针名&)(&实参表&)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include &iostream.h&
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
void main()
//定义类A的一个对象x
//定义一个指向类数据成员的指针pc
//给指针pc赋值
//用指针方式给类成员c赋值为3
int (A::*pfun)(int);
//定义一个指向类成员函数的指针pfun
//给指针pfun赋值
//定义一个对象指针p，并赋初值为x
cout&&(p-&*pfun)(5)&&
//用对象指针调用指向类成员函数指针pfun指向的函数
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout&&x&&&,&&&y&& }
void M::copy(M *m)
void fun(M m1, M *m2);
void main()
M p(5, 7),
q.copy(&p);
fun(p, &q);
p.print();
q.print();
void fun(M m1, M *m2)
m1.setxy(12, 15);
m2-&setxy(22,25);
输出结果为：
从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2-&setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout&&x&&&,&&&y&& }
void M::copy(M &m)
void fun(M m1, M &m2;);
void main()
M p(5, 7),
q.copy(p);
fun(p, q);
p.print();
q.print();
void fun(M m1, M &m2;)
m1.setxy(12, 15);
m2.setxy(22, 25);
该例子与上面的例子输出相同的结果，只是调用时的参数不一样。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include &iostream.h&
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &);
//对象引用作函数参数
void print() {cout&&a&&&,&&&b&& }
void A::copy(A &)
if (this == &)
//这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
//*this是操作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
void main()
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
运行结果：
指向类的成员的指针
在C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
&类型说明符&&类名&::*&指针名&
指向成员函数的指针格式如下：
&类型说明符&(&类名&::*&指针名&)(&参数表&)
例如，设有如下一个类A：
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::
由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符-&*。例如：
A *p = &a;
//a是类A的一个对象，p是指向对象a的指针。
p -&* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
&类型说明符&*&指向函数指针名&(&参数表&)
关于给指向函数的指针赋值的格式如下：
&指向函数的指针名&=&函数名&
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*&指向函数的指针名&)(&实参表&)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include &iostream.h&
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
void main()
//定义类A的一个对象x
//定义一个指向类数据成员的指针pc
//给指针pc赋值
//用指针方式给类成员c赋值为3
int (A::*pfun)(int);
//定义一个指向类成员函数的指针pfun
//给指针pfun赋值
//定义一个对象指针p，并赋初值为x
cout&&(p-&*pfun)(5)&&
//用对象指针调用指向类成员函数指针pfun指向的函数
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout&&x&&&,&&&y&& }
void M::copy(M *m)
void fun(M m1, M *m2);
void main()
M p(5, 7),
q.copy(&p);
fun(p, &q);
p.print();
q.print();
void fun(M m1, M *m2)
m1.setxy(12, 15);
m2-&setxy(22,25);
输出结果为：
从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2-&setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout&&x&&&,&&&y&& }
void M::copy(M &m)
void fun(M m1, M &m2;);
void main()
M p(5, 7),
q.copy(p);
fun(p, q);
p.print();
q.print();
void fun(M m1, M &m2;)
m1.setxy(12, 15);
m2.setxy(22, 25);
该例子与上面的例子输出相同的结果，只是调用时的参数不一样。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include &iostream.h&
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &);
//对象引用作函数参数
void print() {cout&&a&&&,&&&b&& }
void A::copy(A &)
if (this == &)
//这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
//*this是操作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
void main()
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
运行结果：
指向类的成员的指针
在C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
&类型说明符&&类名&::*&指针名&
指向成员函数的指针格式如下：
&类型说明符&(&类名&::*&指针名&)(&参数表&)
例如，设有如下一个类A：
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::
由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符-&*。例如：
A *p = &a;
//a是类A的一个对象，p是指向对象a的指针。
p -&* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
&类型说明符&*&指向函数指针名&(&参数表&)
关于给指向函数的指针赋值的格式如下：
&指向函数的指针名&=&函数名&
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*&指向函数的指针名&)(&实参表&)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include &iostream.h&
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
void main()
//定义类A的一个对象x
//定义一个指向类数据成员的指针pc
//给指针pc赋值
//用指针方式给类成员c赋值为3
int (A::*pfun)(int);
//定义一个指向类成员函数的指针pfun
//给指针pfun赋值
//定义一个对象指针p，并赋初值为x
cout&&(p-&*pfun)(5)&&
//用对象指针调用指向类成员函数指针pfun指向的函数
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout&&x&&&,&&&y&& }
void M::copy(M *m)
void fun(M m1, M *m2);
void main()
M p(5, 7),
q.copy(&p);
fun(p, &q);
p.print();
q.print();
void fun(M m1, M *m2)
m1.setxy(12, 15);
m2-&setxy(22,25);
输出结果为：
从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2-&setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout&&x&&&,&&&y&& }
void M::copy(M &m)
void fun(M m1, M &m2;);
void main()
M p(5, 7),
q.copy(p);
fun(p, q);
p.print();
q.print();
void fun(M m1, M &m2;)
m1.setxy(12, 15);
m2.setxy(22, 25);
该例子与上面的例子输出相同的结果，只是调用时的参数不一样。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include &iostream.h&
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &);
//对象引用作函数参数
void print() {cout&&a&&&,&&&b&& }
void A::copy(A &)
if (this == &)
//这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
//*this是操作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
void main()
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
运行结果：
指向类的成员的指针
在C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
&类型说明符&&类名&::*&指针名&
指向成员函数的指针格式如下：
&类型说明符&(&类名&::*&指针名&)(&参数表&)
例如，设有如下一个类A：
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::
由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符-&*。例如：
A *p = &a;
//a是类A的一个对象，p是指向对象a的指针。
p -&* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
&类型说明符&*&指向函数指针名&(&参数表&)
关于给指向函数的指针赋值的格式如下：
&指向函数的指针名&=&函数名&
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*&指向函数的指针名&)(&实参表&)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include &iostream.h&
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
void main()
//定义类A的一个对象x
//定义一个指向类数据成员的指针pc
//给指针pc赋值
//用指针方式给类成员c赋值为3
int (A::*pfun)(int);
//定义一个指向类成员函数的指针pfun
//给指针pfun赋值
//定义一个对象指针p，并赋初值为x
cout&&(p-&*pfun)(5)&&
//用对象指针调用指向类成员函数指针pfun指向的函数
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout&&x&&&,&&&y&& }
void M::copy(M *m)
void fun(M m1, M *m2);
void main()
M p(5, 7),
q.copy(&p);
fun(p, &q);
p.print();
q.print();
void fun(M m1, M *m2)
m1.setxy(12, 15);
m2-&setxy(22,25);
输出结果为：
从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2-&setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout&&x&&&,&&&y&& }
void M::copy(M &m)
void fun(M m1, M &m2;);
void main()
M p(5, 7),
q.copy(p);
fun(p, q);
p.print();
q.print();
void fun(M m1, M &m2;)
m1.setxy(12, 15);
m2.setxy(22, 25);
该例子与上面的例子输出相同的结果，只是调用时的参数不一样。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include &iostream.h&
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &);
//对象引用作函数参数
void print() {cout&&a&&&,&&&b&& }
void A::copy(A &)
if (this == &)
//这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
//*this是操作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
void main()
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
运行结果：
指向类的成员的指针
在C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
&类型说明符&&类名&::*&指针名&
指向成员函数的指针格式如下：
&类型说明符&(&类名&::*&指针名&)(&参数表&)
例如，设有如下一个类A：
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::
由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符-&*。例如：
A *p = &a;
//a是类A的一个对象，p是指向对象a的指针。
p -&* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
&类型说明符&*&指向函数指针名&(&参数表&)
关于给指向函数的指针赋值的格式如下：
&指向函数的指针名&=&函数名&
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*&指向函数的指针名&)(&实参表&)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include &iostream.h&
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
void main()
//定义类A的一个对象x
//定义一个指向类数据成员的指针pc
//给指针pc赋值
//用指针方式给类成员c赋值为3
int (A::*pfun)(int);
//定义一个指向类成员函数的指针pfun
//给指针pfun赋值
//定义一个对象指针p，并赋初值为x
cout&&(p-&*pfun)(5)&&
//用对象指针调用指向类成员函数指针pfun指向的函数
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout&&x&&&,&&&y&& }
void M::copy(M *m)
void fun(M m1, M *m2);
void main()
M p(5, 7),
q.copy(&p);
fun(p, &q);
p.print();
q.print();
void fun(M m1, M *m2)
m1.setxy(12, 15);
m2-&setxy(22,25);
输出结果为：
从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2-&setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout&&x&&&,&&&y&& }
void M::copy(M &m)
void fun(M m1, M &m2;);
void main()
M p(5, 7),
q.copy(p);
fun(p, q);
p.print();
q.print();
void fun(M m1, M &m2;)
m1.setxy(12, 15);
m2.setxy(22, 25);
该例子与上面的例子输出相同的结果，只是调用时的参数不一样。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include &iostream.h&
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &);
//对象引用作函数参数
void print() {cout&&a&&&,&&&b&& }
void A::copy(A &)
if (this == &)
//这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
//*this是操作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
void main()
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
运行结果：
指向类的成员的指针
在C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
&类型说明符&&类名&::*&指针名&
指向成员函数的指针格式如下：
&类型说明符&(&类名&::*&指针名&)(&参数表&)
例如，设有如下一个类A：
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::
由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符-&*。例如：
A *p = &a;
//a是类A的一个对象，p是指向对象a的指针。
p -&* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
&类型说明符&*&指向函数指针名&(&参数表&)
关于给指向函数的指针赋值的格式如下：
&指向函数的指针名&=&函数名&
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*&指向函数的指针名&)(&实参表&)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include &iostream.h&
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
void main()
//定义类A的一个对象x
//定义一个指向类数据成员的指针pc
//给指针pc赋值
//用指针方式给类成员c赋值为3
int (A::*pfun)(int);
//定义一个指向类成员函数的指针pfun
//给指针pfun赋值
//定义一个对象指针p，并赋初值为x
cout&&(p-&*pfun)(5)&&
//用对象指针调用指向类成员函数指针pfun指向的函数
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout&&x&&&,&&&y&& }
void M::copy(M *m)
void fun(M m1, M *m2);
void main()
M p(5, 7),
q.copy(&p);
fun(p, &q);
p.print();
q.print();
void fun(M m1, M *m2)
m1.setxy(12, 15);
m2-&setxy(22,25);
输出结果为：
从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2-&setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout&&x&&&,&&&y&& }
void M::copy(M &m)
void fun(M m1, M &m2;);
void main()
M p(5, 7),
q.copy(p);
fun(p, q);
p.print();
q.print();
void fun(M m1, M &m2;)
m1.setxy(12, 15);
m2.setxy(22, 25);
该例子与上面的例子输出相同的结果，只是调用时的参数不一样。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include &iostream.h&
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &);
//对象引用作函数参数
void print() {cout&&a&&&,&&&b&& }
void A::copy(A &)
if (this == &)
//这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
//*this是操作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
void main()
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
运行结果：
指向类的成员的指针
在C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
&类型说明符&&类名&::*&指针名&
指向成员函数的指针格式如下：
&类型说明符&(&类名&::*&指针名&)(&参数表&)
例如，设有如下一个类A：
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::
由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符-&*。例如：
A *p = &a;
//a是类A的一个对象，p是指向对象a的指针。
p -&* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
&类型说明符&*&指向函数指针名&(&参数表&)
关于给指向函数的指针赋值的格式如下：
&指向函数的指针名&=&函数名&
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*&指向函数的指针名&)(&实参表&)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include &iostream.h&
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
void main()
//定义类A的一个对象x
//定义一个指向类数据成员的指针pc
//给指针pc赋值
//用指针方式给类成员c赋值为3
int (A::*pfun)(int);
//定义一个指向类成员函数的指针pfun
//给指针pfun赋值
//定义一个对象指针p，并赋初值为x
cout&&(p-&*pfun)(5)&&
//用对象指针调用指向类成员函数指针pfun指向的函数
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout&&x&&&,&&&y&& }
void M::copy(M *m)
void fun(M m1, M *m2);
void main()
M p(5, 7),
q.copy(&p);
fun(p, &q);
p.print();
q.print();
void fun(M m1, M *m2)
m1.setxy(12, 15);
m2-&setxy(22,25);
输出结果为：
从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2-&setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout&&x&&&,&&&y&& }
void M::copy(M &m)
void fun(M m1, M &m2;);
void main()
M p(5, 7),
q.copy(p);
fun(p, q);
p.print();
q.print();
void fun(M m1, M &m2;)
m1.setxy(12, 15);
m2.setxy(22, 25);
该例子与上面的例子输出相同的结果，只是调用时的参数不一样。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include &iostream.h&
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &);
//对象引用作函数参数
void print() {cout&&a&&&,&&&b&& }
void A::copy(A &)
if (this == &)
//这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
//*this是操作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
void main()
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
运行结果：
指向类的成员的指针
在C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
&类型说明符&&类名&::*&指针名&
指向成员函数的指针格式如下：
&类型说明符&(&类名&::*&指针名&)(&参数表&)
例如，设有如下一个类A：
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::
由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符-&*。例如：
A *p = &a;
//a是类A的一个对象，p是指向对象a的指针。
p -&* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
&类型说明符&*&指向函数指针名&(&参数表&)
关于给指向函数的指针赋值的格式如下：
&指向函数的指针名&=&函数名&
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*&指向函数的指针名&)(&实参表&)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include &iostream.h&
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
void main()
//定义类A的一个对象x
//定义一个指向类数据成员的指针pc
//给指针pc赋值
//用指针方式给类成员c赋值为3
int (A::*pfun)(int);
//定义一个指向类成员函数的指针pfun
//给指针pfun赋值
//定义一个对象指针p，并赋初值为x
cout&&(p-&*pfun)(5)&&
//用对象指针调用指向类成员函数指针pfun指向的函数
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout&&x&&&,&&&y&& }
void M::copy(M *m)
void fun(M m1, M *m2);
void main()
M p(5, 7),
q.copy(&p);
fun(p, &q);
p.print();
q.print();
void fun(M m1, M *m2)
m1.setxy(12, 15);
m2-&setxy(22,25);
输出结果为：
从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2-&setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include &iostream.h&
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout&&x&&&,&&&y&& }
void M::copy(M &m)
void fun(M m1, M &m2;);
void main()
M p(5, 7),
q.copy(p);
fun(p, q);
p.print();
q.print();
void fun(M m1, M &m2;)
m1.setxy(12, 15);
m2.setxy(22, 25);
该例子与上面的例子输出相同的结果，只是调用时的参数不一样。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include &iostream.h&
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &);
//对象引用作函数参数
void print() {cout&&a&&&,&&&b&& }
void A::copy(A &)
if (this == &)
//这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
//*this是操作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
void main()
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
运行结果：
...展开收缩
综合评分：4
{%username%}回复{%com_username%}{%time%}\
/*点击出现回复框*/
$(".respond_btn").on("click", function (e) {
$(this).parents(".rightLi").children(".respond_box").show();
e.stopPropagation();
$(".cancel_res").on("click", function (e) {
$(this).parents(".res_b").siblings(".res_area").val("");
$(this).parents(".respond_box").hide();
e.stopPropagation();
/*删除评论*/
$(".del_comment_c").on("click", function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_invalid/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parents(".conLi").remove();
alert(data.msg);
$(".res_btn").click(function (e) {
var parentWrap = $(this).parents(".respond_box"),
q = parentWrap.find(".form1").serializeArray(),
resStr = $.trim(parentWrap.find(".res_area_r").val());
console.log(q);
//var res_area_r = $.trim($(".res_area_r").val());
if (resStr == '') {
$(".res_text").css({color: "red"});
$.post("/index.php/comment/do_comment_reply/", q,
function (data) {
if (data.succ == 1) {
var $target,
evt = e || window.
$target = $(evt.target || evt.srcElement);
var $dd = $target.parents('dd');
var $wrapReply = $dd.find('.respond_box');
console.log($wrapReply);
//var mess = $(".res_area_r").val();
var mess = resS
var str = str.replace(/{%header%}/g, data.header)
.replace(/{%href%}/g, 'http://' + window.location.host + '/user/' + data.username)
.replace(/{%username%}/g, data.username)
.replace(/{%com_username%}/g, data.com_username)
.replace(/{%time%}/g, data.time)
.replace(/{%id%}/g, data.id)
.replace(/{%mess%}/g, mess);
$dd.after(str);
$(".respond_box").hide();
$(".res_area_r").val("");
$(".res_area").val("");
$wrapReply.hide();
alert(data.msg);
}, "json");
/*删除回复*/
$(".rightLi").on("click", '.del_comment_r', function (e) {
var id = $(e.target).attr("id");
$.getJSON('/index.php/comment/do_comment_del/' + id,
function (data) {
if (data.succ == 1) {
$(e.target).parent().parent().parent().parent().parent().remove();
$(e.target).parents('.res_list').remove()
alert(data.msg);
//填充回复
function KeyP(v) {
var parentWrap = $(v).parents(".respond_box");
parentWrap.find(".res_area_r").val($.trim(parentWrap.find(".res_area").val()));
评论共有4条
针对某一块具体展开，学得更深
有点杂乱啊
讲的很详细，有收获，有一点不足之处就是有些例子没有讲透。导致有些地方看不懂。
VIP会员动态
CSDN下载频道资源及相关规则调整公告V11.10
下载频道用户反馈专区
下载频道积分规则调整V1710.18
spring mvc+mybatis+mysql+maven+bootstrap 整合实现增删查改简单实例.zip
资源所需积分/C币
当前拥有积分
当前拥有C币
输入下载码
为了良好体验，不建议使用迅雷下载
C++对象和指针的引用
会员到期时间：
剩余下载个数：
剩余积分：0
为了良好体验，不建议使用迅雷下载
积分不足！
资源所需积分/C币
当前拥有积分
您可以选择
程序员的必选
绿色安全资源
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
为了良好体验，不建议使用迅雷下载
资源所需积分/C币
当前拥有积分
当前拥有C币
您的积分不足，将扣除 10 C币
为了良好体验，不建议使用迅雷下载
无法举报自己的资源
你当前的下载分为234。
你还不是VIP会员
开通VIP会员权限，免积分下载
你下载资源过于频繁，请输入验证码
您因违反CSDN下载频道规则而被锁定帐户，如有疑问，请联络:!
若举报审核通过，可返还被扣除的积分
被举报人：
conly_love2008
请选择类型
资源无法下载 （ 404页面、下载失败、资源本身问题）
资源无法使用 （文件损坏、内容缺失、题文不符）
侵犯版权资源 （侵犯公司或个人版权）
虚假资源 （恶意欺诈、刷分资源）
含色情、危害国家安全内容
含广告、木马病毒资源
*投诉人姓名：
*投诉人联系方式：
*版权证明：
*详细原因：
C++对象和指针的引用}