指向类的成员的指针
在
C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
::*
指向成员函数的指针格式如下：
(::*)()
例如，设有如下一个类A：
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的
对象。因此，在使用这类指针时，需要首先指定A类的一个
对象，然后，通过
对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
A a;
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的
对象的。
如果使用指向
对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
A *p = &a; //a是类A的一个
对象，p是指向
对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
*()
关于给指向函数的指针赋值的格式如下：
=
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*)()
如果是指向类的成员函数的指针还应加上相应的
对象名和
对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个
对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个
对象指针p，并赋初值为x
cout<*pfun)(5)<<endl; //用
对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的
对象是不同的。p是指向类的
对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和
对象引用作函数的参数
1.
对象指针作函数的参数
使用
对象指针作为函数参数要经使用
对象作函数参数更普遍一些。因为使用
对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数
对象的值，实现函数之间的信息传递。
(2) 使用
对象指针实参仅将
对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向
对象指针时，调用函数的对应实参应该是某个
对象的地址值，一般使用&后加
对象名。下面举一例子说明
对象指针作函数参数。
#include
class M
{
public:
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<x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为：
5,7
22,25
从输出结果可以看出，当在被调用函数fun中，改变了
对象的数据成员值[m1.setxy(12, 15)]和指向
对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向
对象指针作参数所指向的
对象被改变了，而另一个
对象作参数，形参
对象值改变了，可实参
对象值并没有改变。因此输出上述结果。
2.
对象引用作函数参数
在实际中，使用
对象引用作函数参数要比使用
对象指针作函数更普遍，这是因为使用
对象引用作函数参数具有用
对象指针作函数参数的优点，而用
对象引用作函数参数将更简单，更直接。所以，在
C++编程中，人们喜欢用
对象引用作函数参数。现举一例子说明
对象引用作函数参数的格式。
#include
class M
{
public:
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<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2;);
void main()
{
M p(5, 7), q;
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来标识调用该成员函数的
对象。下面举一例子说明this指针的应用。
#include
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa;); //
对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa;)
{
if (this == &aa;) return; //这个this是操作该成员函数的
对象的地址，在这里是
对象a1的地址
*this = aa; //*this是操作该成员函数的
对象，在这里是
对象a1。
//此语句是
对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果：
3, 4
指向类的成员的指针
在
C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
::*
指向成员函数的指针格式如下：
(::*)()
例如，设有如下一个类A：
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的
对象。因此，在使用这类指针时，需要首先指定A类的一个
对象，然后，通过
对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
A a;
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的
对象的。
如果使用指向
对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
A *p = &a; //a是类A的一个
对象，p是指向
对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
*()
关于给指向函数的指针赋值的格式如下：
=
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*)()
如果是指向类的成员函数的指针还应加上相应的
对象名和
对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个
对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个
对象指针p，并赋初值为x
cout<*pfun)(5)<<endl; //用
对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的
对象是不同的。p是指向类的
对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和
对象引用作函数的参数
1.
对象指针作函数的参数
使用
对象指针作为函数参数要经使用
对象作函数参数更普遍一些。因为使用
对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数
对象的值，实现函数之间的信息传递。
(2) 使用
对象指针实参仅将
对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向
对象指针时，调用函数的对应实参应该是某个
对象的地址值，一般使用&后加
对象名。下面举一例子说明
对象指针作函数参数。
#include
class M
{
public:
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<x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为：
5,7
22,25
从输出结果可以看出，当在被调用函数fun中，改变了
对象的数据成员值[m1.setxy(12, 15)]和指向
对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向
对象指针作参数所指向的
对象被改变了，而另一个
对象作参数，形参
对象值改变了，可实参
对象值并没有改变。因此输出上述结果。
2.
对象引用作函数参数
在实际中，使用
对象引用作函数参数要比使用
对象指针作函数更普遍，这是因为使用
对象引用作函数参数具有用
对象指针作函数参数的优点，而用
对象引用作函数参数将更简单，更直接。所以，在
C++编程中，人们喜欢用
对象引用作函数参数。现举一例子说明
对象引用作函数参数的格式。
#include
class M
{
public:
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<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2;);
void main()
{
M p(5, 7), q;
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来标识调用该成员函数的
对象。下面举一例子说明this指针的应用。
#include
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa;); //
对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa;)
{
if (this == &aa;) return; //这个this是操作该成员函数的
对象的地址，在这里是
对象a1的地址
*this = aa; //*this是操作该成员函数的
对象，在这里是
对象a1。
//此语句是
对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果：
3, 4
指向类的成员的指针
在
C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
::*
指向成员函数的指针格式如下：
(::*)()
例如，设有如下一个类A：
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的
对象。因此，在使用这类指针时，需要首先指定A类的一个
对象，然后，通过
对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
A a;
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的
对象的。
如果使用指向
对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
A *p = &a; //a是类A的一个
对象，p是指向
对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
*()
关于给指向函数的指针赋值的格式如下：
=
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*)()
如果是指向类的成员函数的指针还应加上相应的
对象名和
对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个
对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个
对象指针p，并赋初值为x
cout<*pfun)(5)<<endl; //用
对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的
对象是不同的。p是指向类的
对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和
对象引用作函数的参数
1.
对象指针作函数的参数
使用
对象指针作为函数参数要经使用
对象作函数参数更普遍一些。因为使用
对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数
对象的值，实现函数之间的信息传递。
(2) 使用
对象指针实参仅将
对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向
对象指针时，调用函数的对应实参应该是某个
对象的地址值，一般使用&后加
对象名。下面举一例子说明
对象指针作函数参数。
#include
class M
{
public:
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<x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为：
5,7
22,25
从输出结果可以看出，当在被调用函数fun中，改变了
对象的数据成员值[m1.setxy(12, 15)]和指向
对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向
对象指针作参数所指向的
对象被改变了，而另一个
对象作参数，形参
对象值改变了，可实参
对象值并没有改变。因此输出上述结果。
2.
对象引用作函数参数
在实际中，使用
对象引用作函数参数要比使用
对象指针作函数更普遍，这是因为使用
对象引用作函数参数具有用
对象指针作函数参数的优点，而用
对象引用作函数参数将更简单，更直接。所以，在
C++编程中，人们喜欢用
对象引用作函数参数。现举一例子说明
对象引用作函数参数的格式。
#include
class M
{
public:
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<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2;);
void main()
{
M p(5, 7), q;
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来标识调用该成员函数的
对象。下面举一例子说明this指针的应用。
#include
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa;); //
对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa;)
{
if (this == &aa;) return; //这个this是操作该成员函数的
对象的地址，在这里是
对象a1的地址
*this = aa; //*this是操作该成员函数的
对象，在这里是
对象a1。
//此语句是
对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果：
3, 4
指向类的成员的指针
在
C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
::*
指向成员函数的指针格式如下：
(::*)()
例如，设有如下一个类A：
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的
对象。因此，在使用这类指针时，需要首先指定A类的一个
对象，然后，通过
对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
A a;
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的
对象的。
如果使用指向
对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
A *p = &a; //a是类A的一个
对象，p是指向
对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
*()
关于给指向函数的指针赋值的格式如下：
=
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*)()
如果是指向类的成员函数的指针还应加上相应的
对象名和
对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个
对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个
对象指针p，并赋初值为x
cout<*pfun)(5)<<endl; //用
对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的
对象是不同的。p是指向类的
对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和
对象引用作函数的参数
1.
对象指针作函数的参数
使用
对象指针作为函数参数要经使用
对象作函数参数更普遍一些。因为使用
对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数
对象的值，实现函数之间的信息传递。
(2) 使用
对象指针实参仅将
对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向
对象指针时，调用函数的对应实参应该是某个
对象的地址值，一般使用&后加
对象名。下面举一例子说明
对象指针作函数参数。
#include
class M
{
public:
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<x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为：
5,7
22,25
从输出结果可以看出，当在被调用函数fun中，改变了
对象的数据成员值[m1.setxy(12, 15)]和指向
对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向
对象指针作参数所指向的
对象被改变了，而另一个
对象作参数，形参
对象值改变了，可实参
对象值并没有改变。因此输出上述结果。
2.
对象引用作函数参数
在实际中，使用
对象引用作函数参数要比使用
对象指针作函数更普遍，这是因为使用
对象引用作函数参数具有用
对象指针作函数参数的优点，而用
对象引用作函数参数将更简单，更直接。所以，在
C++编程中，人们喜欢用
对象引用作函数参数。现举一例子说明
对象引用作函数参数的格式。
#include
class M
{
public:
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<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2;);
void main()
{
M p(5, 7), q;
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来标识调用该成员函数的
对象。下面举一例子说明this指针的应用。
#include
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa;); //
对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa;)
{
if (this == &aa;) return; //这个this是操作该成员函数的
对象的地址，在这里是
对象a1的地址
*this = aa; //*this是操作该成员函数的
对象，在这里是
对象a1。
//此语句是
对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果：
3, 4
指向类的成员的指针
在
C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
::*
指向成员函数的指针格式如下：
(::*)()
例如，设有如下一个类A：
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的
对象。因此，在使用这类指针时，需要首先指定A类的一个
对象，然后，通过
对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
A a;
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的
对象的。
如果使用指向
对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
A *p = &a; //a是类A的一个
对象，p是指向
对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
*()
关于给指向函数的指针赋值的格式如下：
=
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*)()
如果是指向类的成员函数的指针还应加上相应的
对象名和
对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个
对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个
对象指针p，并赋初值为x
cout<*pfun)(5)<<endl; //用
对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的
对象是不同的。p是指向类的
对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和
对象引用作函数的参数
1.
对象指针作函数的参数
使用
对象指针作为函数参数要经使用
对象作函数参数更普遍一些。因为使用
对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数
对象的值，实现函数之间的信息传递。
(2) 使用
对象指针实参仅将
对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向
对象指针时，调用函数的对应实参应该是某个
对象的地址值，一般使用&后加
对象名。下面举一例子说明
对象指针作函数参数。
#include
class M
{
public:
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<x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为：
5,7
22,25
从输出结果可以看出，当在被调用函数fun中，改变了
对象的数据成员值[m1.setxy(12, 15)]和指向
对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向
对象指针作参数所指向的
对象被改变了，而另一个
对象作参数，形参
对象值改变了，可实参
对象值并没有改变。因此输出上述结果。
2.
对象引用作函数参数
在实际中，使用
对象引用作函数参数要比使用
对象指针作函数更普遍，这是因为使用
对象引用作函数参数具有用
对象指针作函数参数的优点，而用
对象引用作函数参数将更简单，更直接。所以，在
C++编程中，人们喜欢用
对象引用作函数参数。现举一例子说明
对象引用作函数参数的格式。
#include
class M
{
public:
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<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2;);
void main()
{
M p(5, 7), q;
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来标识调用该成员函数的
对象。下面举一例子说明this指针的应用。
#include
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa;); //
对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa;)
{
if (this == &aa;) return; //这个this是操作该成员函数的
对象的地址，在这里是
对象a1的地址
*this = aa; //*this是操作该成员函数的
对象，在这里是
对象a1。
//此语句是
对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果：
3, 4
指向类的成员的指针
在
C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
::*
指向成员函数的指针格式如下：
(::*)()
例如，设有如下一个类A：
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的
对象。因此，在使用这类指针时，需要首先指定A类的一个
对象，然后，通过
对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
A a;
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的
对象的。
如果使用指向
对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
A *p = &a; //a是类A的一个
对象，p是指向
对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
*()
关于给指向函数的指针赋值的格式如下：
=
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*)()
如果是指向类的成员函数的指针还应加上相应的
对象名和
对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个
对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个
对象指针p，并赋初值为x
cout<*pfun)(5)<<endl; //用
对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的
对象是不同的。p是指向类的
对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和
对象引用作函数的参数
1.
对象指针作函数的参数
使用
对象指针作为函数参数要经使用
对象作函数参数更普遍一些。因为使用
对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数
对象的值，实现函数之间的信息传递。
(2) 使用
对象指针实参仅将
对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向
对象指针时，调用函数的对应实参应该是某个
对象的地址值，一般使用&后加
对象名。下面举一例子说明
对象指针作函数参数。
#include
class M
{
public:
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<x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为：
5,7
22,25
从输出结果可以看出，当在被调用函数fun中，改变了
对象的数据成员值[m1.setxy(12, 15)]和指向
对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向
对象指针作参数所指向的
对象被改变了，而另一个
对象作参数，形参
对象值改变了，可实参
对象值并没有改变。因此输出上述结果。
2.
对象引用作函数参数
在实际中，使用
对象引用作函数参数要比使用
对象指针作函数更普遍，这是因为使用
对象引用作函数参数具有用
对象指针作函数参数的优点，而用
对象引用作函数参数将更简单，更直接。所以，在
C++编程中，人们喜欢用
对象引用作函数参数。现举一例子说明
对象引用作函数参数的格式。
#include
class M
{
public:
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<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2;);
void main()
{
M p(5, 7), q;
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来标识调用该成员函数的
对象。下面举一例子说明this指针的应用。
#include
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa;); //
对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa;)
{
if (this == &aa;) return; //这个this是操作该成员函数的
对象的地址，在这里是
对象a1的地址
*this = aa; //*this是操作该成员函数的
对象，在这里是
对象a1。
//此语句是
对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果：
3, 4
指向类的成员的指针
在
C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
::*
指向成员函数的指针格式如下：
(::*)()
例如，设有如下一个类A：
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的
对象。因此，在使用这类指针时，需要首先指定A类的一个
对象，然后，通过
对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
A a;
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的
对象的。
如果使用指向
对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
A *p = &a; //a是类A的一个
对象，p是指向
对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
*()
关于给指向函数的指针赋值的格式如下：
=
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*)()
如果是指向类的成员函数的指针还应加上相应的
对象名和
对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个
对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个
对象指针p，并赋初值为x
cout<*pfun)(5)<<endl; //用
对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的
对象是不同的。p是指向类的
对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和
对象引用作函数的参数
1.
对象指针作函数的参数
使用
对象指针作为函数参数要经使用
对象作函数参数更普遍一些。因为使用
对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数
对象的值，实现函数之间的信息传递。
(2) 使用
对象指针实参仅将
对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向
对象指针时，调用函数的对应实参应该是某个
对象的地址值，一般使用&后加
对象名。下面举一例子说明
对象指针作函数参数。
#include
class M
{
public:
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<x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为：
5,7
22,25
从输出结果可以看出，当在被调用函数fun中，改变了
对象的数据成员值[m1.setxy(12, 15)]和指向
对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向
对象指针作参数所指向的
对象被改变了，而另一个
对象作参数，形参
对象值改变了，可实参
对象值并没有改变。因此输出上述结果。
2.
对象引用作函数参数
在实际中，使用
对象引用作函数参数要比使用
对象指针作函数更普遍，这是因为使用
对象引用作函数参数具有用
对象指针作函数参数的优点，而用
对象引用作函数参数将更简单，更直接。所以，在
C++编程中，人们喜欢用
对象引用作函数参数。现举一例子说明
对象引用作函数参数的格式。
#include
class M
{
public:
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<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2;);
void main()
{
M p(5, 7), q;
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来标识调用该成员函数的
对象。下面举一例子说明this指针的应用。
#include
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa;); //
对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa;)
{
if (this == &aa;) return; //这个this是操作该成员函数的
对象的地址，在这里是
对象a1的地址
*this = aa; //*this是操作该成员函数的
对象，在这里是
对象a1。
//此语句是
对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果：
3, 4
指向类的成员的指针
在
C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
::*
指向成员函数的指针格式如下：
(::*)()
例如，设有如下一个类A：
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的
对象。因此，在使用这类指针时，需要首先指定A类的一个
对象，然后，通过
对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
A a;
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的
对象的。
如果使用指向
对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
A *p = &a; //a是类A的一个
对象，p是指向
对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
*()
关于给指向函数的指针赋值的格式如下：
=
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*)()
如果是指向类的成员函数的指针还应加上相应的
对象名和
对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个
对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个
对象指针p，并赋初值为x
cout<*pfun)(5)<<endl; //用
对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的
对象是不同的。p是指向类的
对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和
对象引用作函数的参数
1.
对象指针作函数的参数
使用
对象指针作为函数参数要经使用
对象作函数参数更普遍一些。因为使用
对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数
对象的值，实现函数之间的信息传递。
(2) 使用
对象指针实参仅将
对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向
对象指针时，调用函数的对应实参应该是某个
对象的地址值，一般使用&后加
对象名。下面举一例子说明
对象指针作函数参数。
#include
class M
{
public:
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<x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为：
5,7
22,25
从输出结果可以看出，当在被调用函数fun中，改变了
对象的数据成员值[m1.setxy(12, 15)]和指向
对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向
对象指针作参数所指向的
对象被改变了，而另一个
对象作参数，形参
对象值改变了，可实参
对象值并没有改变。因此输出上述结果。
2.
对象引用作函数参数
在实际中，使用
对象引用作函数参数要比使用
对象指针作函数更普遍，这是因为使用
对象引用作函数参数具有用
对象指针作函数参数的优点，而用
对象引用作函数参数将更简单，更直接。所以，在
C++编程中，人们喜欢用
对象引用作函数参数。现举一例子说明
对象引用作函数参数的格式。
#include
class M
{
public:
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<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2;);
void main()
{
M p(5, 7), q;
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来标识调用该成员函数的
对象。下面举一例子说明this指针的应用。
#include
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa;); //
对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa;)
{
if (this == &aa;) return; //这个this是操作该成员函数的
对象的地址，在这里是
对象a1的地址
*this = aa; //*this是操作该成员函数的
对象，在这里是
对象a1。
//此语句是
对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果：
3, 4
指向类的成员的指针
在
C++中，可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下：
::*
指向成员函数的指针格式如下：
(::*)()
例如，设有如下一个类A：
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc，其格式如下：
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的
对象。因此，在使用这类指针时，需要首先指定A类的一个
对象，然后，通过
对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：
A a;
a.*pc = 8;
其中，运算符.*是用来对指向类成员的指针来操作该类的
对象的。
如果使用指向
对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
A *p = &a; //a是类A的一个
对象，p是指向
对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式：
*()
关于给指向函数的指针赋值的格式如下：
=
关于在程序中，使用指向函数的指针调用函数的格式如下：
(*)()
如果是指向类的成员函数的指针还应加上相应的
对象名和
对象成员运算符。
下面给出一个使用指向类成员指针的例子：
#include
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个
对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个
对象指针p，并赋初值为x
cout<*pfun)(5)<<endl; //用
对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针，虽然它们都是指针，但是所指向的
对象是不同的。p是指向类的
对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和
对象引用作函数的参数
1.
对象指针作函数的参数
使用
对象指针作为函数参数要经使用
对象作函数参数更普遍一些。因为使用
对象指针作函数参数有如下两点好处：
(1) 实现传址调用。可在被调用函数中改变调用函数的参数
对象的值，实现函数之间的信息传递。
(2) 使用
对象指针实参仅将
对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。
当形参是指向
对象指针时，调用函数的对应实参应该是某个
对象的地址值，一般使用&后加
对象名。下面举一例子说明
对象指针作函数参数。
#include
class M
{
public:
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<x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为：
5,7
22,25
从输出结果可以看出，当在被调用函数fun中，改变了
对象的数据成员值[m1.setxy(12, 15)]和指向
对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向
对象指针作参数所指向的
对象被改变了，而另一个
对象作参数，形参
对象值改变了，可实参
对象值并没有改变。因此输出上述结果。
2.
对象引用作函数参数
在实际中，使用
对象引用作函数参数要比使用
对象指针作函数更普遍，这是因为使用
对象引用作函数参数具有用
对象指针作函数参数的优点，而用
对象引用作函数参数将更简单，更直接。所以，在
C++编程中，人们喜欢用
对象引用作函数参数。现举一例子说明
对象引用作函数参数的格式。
#include
class M
{
public:
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<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2;);
void main()
{
M p(5, 7), q;
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来标识调用该成员函数的
对象。下面举一例子说明this指针的应用。
#include
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa;); //
对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa;)
{
if (this == &aa;) return; //这个this是操作该成员函数的
对象的地址，在这里是
对象a1的地址
*this = aa; //*this是操作该成员函数的
对象，在这里是
对象a1。
//此语句是
对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果：
3, 4
本文探讨了Java与C/C++的主要区别，重点讨论了两者在指针与引用上的不同实现方式，包括对象的创建、内存管理及参数传递等方面。
扫一扫
2919
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
