随笔——重载函数+构造函数+析构函数

//构造函数&&重载函数
#include<iostream>
using namespace std;
class node
{
private:
    int x,y;
public:
    node()//默认构造函数
    {
        x=0;
        y=0;
    }
    node(int a);//构造函数重载
    node(int a,int b)//构造函数重载
    {
        x=a;
        y=b;
    }
    out()
    {
        cout<<x<<" "<<y<<endl;
    }
};
node::node(int a):x(a),y(a)//x(a)相当于x=a,y(a)亦如。
{
}
int main()
{
    node p(5);
    p.out();
    node q(1,3);
    q.out();
}
/*
类的私有成员及函数无法在外界访问,只能通过建立公有函数访问。
*/

//构造函数在数组中的使用
#include<iostream>
using namespace std;
class node
{
private:
    int x,y;
public:
    node()
    {
        cout<<"node 1"<<endl;
    }
    node(int a,int b)
    {
        cout<<"node 2"<<endl;
    }
};
int main()
{
    node array1[2];
    cout<<"step1"<<endl;
    node array2[2]={{1,2},{3,4}};
    cout<<"step2"<<endl;
    node array3[2]={{1,2}};
    cout<<"step3"<<endl;
    return 0;
}
/*
node 1
node 1
step1
node 2
node 2
step2
node 2
node 1
step3
  在step1因为array1[2]没有参数，所以两个都调用无参函数。step2中有
参数，调用第二个构造函数函数。第三个array3[1]有参数，array[2]没有参数。先
调用第二个构造函数，再调用第一个构造函数。
*/

//复制构造函数
#include<iostream>
using namespace std;
class node
{
private:
    int x,y;
public:
    init()
    {
        int a, b;
        cin>>a>>b;
        x=a,y=b;
    }
    out()
    {
        cout<<x<<" "<<y<<endl;
    }
};
int main()
{
    node p1;
    p1.init();
    cout<<"p1 parameter:"<<endl;
    p1.out();
    node p2(p1);//默认复制构造函数的调用
    cout<<"p2 parameter:"<<endl;
    p1.out();
}
/*
复制构造函数也是构造函数的一种，也称拷贝函数，只用一个参数，参数时本类的
引用。如果没有定义复制构造函数，编译器就会自动生成复制构造函数。
*/

#include<iostream>
using namespace std;
class node
{
public:
    int x,y;
    node(){};
    node(node& a)//复制构造函数
    {
        cout<<"*******"<<endl;
        x=1,y=2;
    }
};
void F(node a)
{
    cout<<a.x<<" "<<a.y;
}
int main()
{
    node b;
    b.x=4,b.y=5;
    F(b);//把实参（b）穿给形参（a）
}
/*
函数的形参是用复制构造函数初始化的，把实参传给形参时，复制构造函数
会被调用.
*/

//析构函数
#include<iostream>
using namespace std;
class node
{
public:
    ~node()//析构函数
    {
        cout<<"die...."<<endl;
    };
};
void F()
{
    node a;
    return ;//函数调用结束后类a消亡。
}
int main()
{
    node *p;
    p=new node;
    delete p;//删除类，类消亡。
    cout<<"------------"<<endl;
    F();
}
/*
输出结果:
die....
------------
die....

   析构函数是在类消亡时会默认调用的函数，每当这个类消亡，
便调用这个类的析构函数。
*/