c++中直接用类的对象名加‘.’成员运算符引用操作类的私有成员数据

类的成员数据分私有，公用，保护三种，公用就不必多说了，今天重点讲述私有成员数据的运用。大家都知道，类的私有数据成员能被类的成员函数直接操作，

但当在类的外部（例如在main()函数中）是不能直接引用操作类的私有的对象，否则就会出现错误！请看下面的程序代码：

#include <iostream>
using namespace std;
class tree
{
      private :
              int ages;
      public :
             tree();
             tree(int n=0)
                    {ages=n;}
             ~tree()
             {
                    cout<<"析构函数调用了吗！"<<endl;
             }
              void grow(int years)
             {
                   cout<<"经过生长后";
                  ages+=years;
             }
           void age()
           {
                cout<<"该树的树龄为："<<ages<<endl;
           }
};

int main()
{
    tree tr(18);
    tr.age();
    tree.ages;                                                              //这里就会出现错了，类的私有成员不能直接的引用！
    tr.grow(4);
    tr.age();
    system("pause");
    return 0;
}
上面是最基本的常识，但是直接对类的私有成员在类的外部操作可以通过类的友元函数和友元类来实现！
例如：
#include <iostream>
using namespace std;

class circle
{
      public :
             circle(float r):radius(r)
             {}
             friend float getarea(circle &j);                 必须类的友元函数在类外进行定义，在类内进行声明！
              ~circle()
              {
                 cout<<"调用类的析构函数！";
              }
      private :
              float  radius;
};
 float getarea(circle &j)//请看这里这是类的友元函数，不属于类的内部，
    {
      return j.radius*j.radius*3.1415926;//看这里直接操作j.radius类的私有数据就
    }//没有报错，这是允许的！
int main()
{
    circle o(2);
    cout<<"该圆的面积为："<<getarea(o)<<endl;
    system("pause");
    return 0;
}
至于类的友元类就比比多说类，需要强调的是类的友元类和类的友元函数一样必须要在类的内部声明
在类的外部进行定义！而且友元类的所有成员函数均是该类的友元函数，但是友元类的关系不是互逆的
关系。在这不必多提，有兴趣的同学参考具体的友元类和友元函数的用法。
还有就是要注意一点在友元函数中操作和在本类的成员函数操作是不同的，在类的成员函数是可以直接
利用私有数据名操作（这主要是类的成员函数中都隐含了一个本类的this指针），但是在类的友元类和友元函数
是利用类的对象名加' . '成员操作符实现的。
当类的成员是另一个类的对象的时候（类组合）的情况：例如
#include <iostream>
using namespace std;
class b
{
     //friend class a 
      public:
             b()
             {}
      private:
              int h;
}
class a
{
      public:
             a()
             {}
             void geth()
             {
                  return c.h;此时直接在a类的成员函数操作b类的私有对象，但是a类不是b
             }//友元类所以这里的操作是不允许的！若想实现就只有将a类声明为b类的友元类
      private://才可以 即在b类中要出现 friend class a
              b c;//b类的对象 c
}
在运算符重载的时候会出现这种情况：例如：

#include <iostream>
using namespace std;

class poit3d
{
      public:
             poit3d()
             {}
             poit3d(int l,int b,int v); 
             bool operator==(poit3d &h)
             {
                  if((x==h.x)&&(y==h.y)&&(z==h.z))
                  return true;
                  else
                  return false;
             }
            poit3d &operator+(poit3d &b);  
            poit3d &operator-(poit3d &b);  
            void operator=(poit3d &b);
            void show();
            private:
            int x,y,z;   
};
void poit3d::show()
{
     cout<<"x="<<x<<endl;
     cout<<"y="<<y<<endl;
     cout<<"z="<<z<<endl;
}
poit3d::poit3d(int l,int b,int v)
{
      x=l;
      y=b;
      z=v;
 }
poit3d &poit3d::operator+(poit3d &b)//主要是这里成员函数的参数为一个类的引用！
{
       b.x+=x;//但是这里用到  b.x 这样来操作类的私有数据，但是我一直认为这是在 b
       b.y+=y;//所代表的的类的类外，所以不能这样直接的操作，但是后来才知道，这个
       b.z+=z;//成员函数和这个引用都是属于poit3d类的所以就不会发生错误了！
       return b;
}

//但是注意上面说了成员函数和这个引用都是属于poit3d类的所以才不会发生错误，但是当引用的对象
//和成员函数不属于同一个类是就不允许进行上面的 b.x 操作和前一个一样，如果要实现操作，就
//要靠友元类进行操作了！即将 成员函数所属的类声明为 b.x 对象 b所属类的友元类！才能操作成功！
//
void poit3d::operator=(poit3d &b)
{
       //这里也是一样的！
       x=b.x;//‘= ’前面的x是本类的数据在本类的成员函数进行操作时前面会有一个隐式的this
       y=b.y;//指针，关于类的this指针有兴趣的同学参考其他的资料！
       z=b.z;
}
poit3d &poit3d::operator-(poit3d &b)
{
       b.x-=x;
       b.y-=y;
       b.z-=z;
       return b;
}
int main()
{
    poit3d v(1,2,3),b(4,5,6),m;
    if(v==b)
    cout<<"输出两点相同！"<<endl;
    else
    cout<<"输出两点不相同！"<<endl;
    m=b;
    m.show();
    m=v;
    m.show();
    m=v+b;
    m.show();
    m=b-v;
    m.show();
    system("pause");
    return 0;
}

 注：这是本人第一次写csdn博客，也是第一次写博客，写的非常不好，有什么问题请多多指教，感谢大家的评论，共同进步.......欢迎观看！