随笔——对象进阶

//常量对象和常成员函数
#include<iostream>
using namespace std;
class node
{
public:
    node(){};
    F()const//常成员函数
    {
        cout<<"********"<<endl;
    }
    P()
    {
        cout<<"^^^^^^^^"<<endl;
    }
};
int main()
{
    const node a;
    node b;
    a.F();
//    a.P();//报错，不能通过常量对象访问普通成员函数。
    b.P();
}
/*
常量对象在初始化后就不能再改变，调用普通函数可能会改变常量，所以不能通过常量对象访问
普通成员函数。但是常量对象可以调用常量成员函数。
*/

//友元函数
#include<iostream>
using namespace std;
class node
{
private:
    int x,y;
    friend void init(node a);//把函数init声明为类的友元。
};
void init(node a)//因为是类的友元，可以调用类的私有成员。
{
    cin>>a.x>>a.y;
    cout<<a.x<<" "<<a.y<<endl;
}
int main()
{
    node a;
    init(a);
    return 0;
}

//友元类
#include<iostream>
using namespace std;
class B;
class A
{
private:
    int x;
public:
    friend B;//声明B是A的友元。
    A()
    {
        x=0;
    }
    out()
    {
        cout<<x<<endl;
    }
};
class B
{
public:
    init(int z,A& a)//可以从B访问A的私有成员
    {

        a.x=a.x+z;
    }
};
int main()
{
    A a;
    B b;
    a.out();
    b.init(5,a);
    a.out();
}
/*
当定义一个类（函数）为另一个类的友元时，就可以通过这个类（函数）访问
*/

//this指针
#include<iostream>
using namespace std;
class node
{
private:
    int x;
public:
    node():x(0){};
    void F()//函数V的翻译
    {
        this->x++;
    }
    void V(node& a)//this指针的翻译
    {
        a.x++;
    }
    out()
    {
        cout<<x<<endl;
    }
};
int main()
{
    node a;
    a.out();
    cout<<"--------"<<endl;
    a.F();
    a.out();
    cout<<"--------"<<endl;
    a.V(a);
    a.out();
}
/*
this指针类型是定义的类的类型，同一个类创建多个对象时，多个对象的this指针是
同一个指针，this就是指向对象自身的一个指针。this->x与x是完全等价的。
*/