浅谈C++中的对象指针和对象引用

#include <iostream>
using namespace std;

/**
1\指向类数据成员的指针
2\指向类成员函数的指针
3\一个对象指针
****************/

class A
    {
    public:
        int fun (int b) { return a*c+b; }
        A(int i) { a=i; }
    public:
        int c;
    private:
         int a;
    };

	int  main()
	{
		//int A:: *pc = &A::c;
		A x(8); //定义类A的一个对象x

		int A::*pc; //定义一个指向类数据成员的指针pc
		pc=&A::c;//给指针pc赋值
		x.*pc=3; //用指针方式给类成员c赋值为3
		cout<<"member virable value:"<<x.c<<endl;

		int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
		pfun=&A::fun; //给指针pfun赋值
		A *p=&x;  //定义一个对象指针p，并赋初值为x
		cout<<"invoking value"<<(p->*pfun)(5)<<endl; //用对象指针调用指向类成员函数指针pfun指向的函数
		
		p->c=90;
		cout<<"p->c=90;"<<p->c<<endl; 
		//(x.*pfun)(5)
		return 0;
	}

/**
4\对象指针作函数的参数
****************/

class M1
    {
    public:
        M1() { x=y=0; }
        M1(int i, int j) { x=i; y=j; }
        void copy(M1 *m);
        void setxy(int i, int j) { x=i; y=j; }
        void print() { cout<<x<<","<<y<<endl; }
    private:
        int x, y;
    };

    void M1::copy(M1 *m)
    {
		x=m->x;
		y=m->y;
    }

    void fun(M1 m1, M1 *m2);
	
    void fun(M1 m1, M1 *m2)
    {
		m1.setxy(12, 15);
		m2->setxy(22,25);
    }
	void main()
    {
		M1 p(5, 7), q;
		q.copy(&p);

		fun(p, &q); //注：这和java是不同的，java传对像，形参变实参也会变的,C++是不一样的

		p.print();
		q.print();
   }

/*result:
5,7
        22,25

    从输出结果可以看出，当在被调用函数fun中，
改变了对象的数据成员值[m1.setxy(12, 15)]
和指向对象指针的数据成员值[m2->setxy(22, 25)]以后，
可以看到只有指向对象指针作参数所指向的对象被改变了，
而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。
因此输出上述结果。*/

  

/**
5\对象引用作函数参数
****************/

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);
    }

	void main()
    {
		M p(5, 7), q;
		q.copy(p);
		fun(p, q);
		p.print();
		q.print();
    }

/*result:
5,7
        22,25
    */

//this指针

 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();
    }