【C++碎碎念】面向对象（封装与访问控制、构造函数与析构函数、拷贝函数）

目录

一、封装与访问控制

二、构造函数与析构函数

三、 拷贝构造函数

---

一、封装与访问控制

1、封装的优势：

1）隐藏实现细节，提供公共的访问方式；

2）提高了代码的复用性；

3）提高了安全性。

2、分别分析private public protected的作用

private修饰的内容只能在本类中访问。
public修饰的内容是公共的，谁都可用访问。
protected表示受保护的权限，继承中用的比较多。子类能够访问父类中的内容

代码实现

#include <iostream>
using namespace std;

class Student{
private:
    string m_name;
    int m_age;
    int m_id;
public:
    void setName(string name)
    {
        m_name=name;
    }
    string getName()
    {
        return m_name;
    }

    void setAge(int age)
    {
        m_age=age;
    }
    int getAge()
    {
        return m_age;
    }

    void setId(int id)
    {
        m_id=id;
    }
    int getId()
    {
        return m_id;
    }
};
int main()
{
    Student s;
    s.setName("zhangsan");
    s.setAge(34);
    s.setId(10);

    cout<<"姓名："<<s.getName()<<endl;
    cout<<"年龄："<<s.getAge()<<endl;
    cout<<"学号："<<s.getId()<<endl;

    return 0;
}

 运行结果为：

二、构造函数与析构函数

1、构造函数：在创建对象时为对象的成员进行初始化；

1）构造函数名和类名相同

2）没有返回值，不用写void

3）允许多个参数，可以重载

2、析构函数：在对象销毁前，执行一些清理工作 ；

1）析构函数名和类名相同，前面加上~

2）没有返回值，不用写void

3）不允许多个参数，无参的，不可以重载

注意：

构造函数和析构函数由编译器自动调用一次，无需手动调用。
如果没有提供构造函数，编译器会自动提供一个无参的空实现的构造函数。
如果没有提供析构函数，编译器会自动提供一个无参的空实现的析构函数。

#include <iostream>
using namespace std;

class Student{
public:
    string m_name;
    int m_age;

    Student(){
        m_name="";
        m_age=0;
        cout<<"无参的构造函数执行了..."<<endl;
    }
    Student(string name,int age){  //相当于重载函数
        m_name=name;
        m_age=age;
        cout<<"you参的构造函数执行了..."<<endl;
    }
    ~Student(){
        cout<<"析构函数执行了..."<<endl;
    }

};
int main()
{
    Student s;//创建Student对象，不能Student s()这样定义，如果不定义无参函数就不会打印输出
    Student s1("lisi",56);
    
    cout<<"姓名："<<s1.m_name<<endl;
    cout<<"年龄："<<s1.m_age<<endl;
    return 0;
}

 这个是定义无参函数的：

这个没有定义无参函数的： 

另外：通过输出可以看出，定义多少个构造函数，就会输出多少个析构函数

三、 拷贝构造函数

构造函数分类：

1、按照有无参数：有参构造和无参构造（默认）

2、按照类型分类：拷贝构造和普通构造

如果我们提供了构造函数，系统将不再提供无参的构造函数

拷贝构造函数的调用方式：显示调用和隐式调用

#include <iostream>
using namespace std;

class Student{
public:
    string m_name;
    int m_age;

    Student(){
        m_name="";
        m_age=0;
        cout<<"无参的构造函数执行了..."<<endl;
    }
    Student(string name,int age){  //相当于重载函数
        m_name=name;
        m_age=age;
        cout<<"有参的构造函数执行了..."<<endl;
    }
    Student(const Student &s)//拷贝构造函数
    {
        m_age=s.m_age;
        m_name=s.m_name;
        cout<<"拷贝构造函数执行了..."<<endl;
    }
    ~Student(){
        cout<<"析构函数执行了..."<<endl;
    }

};
int main()
{
    //******显示调用***********
    Student s=Student();//拷贝 无参构造
    Student s1=Student("zhangsan",89);//拷贝 有参构造
    cout<<"姓名1："<<s1.m_name<<endl;
    cout<<"年龄1："<<s1.m_age<<endl;

    Student s2(s1);//将对象s1的内容初始化给s2,等价于Student s2=Student （s1）
    cout<<"姓名2："<<s2.m_name<<endl;
    cout<<"年龄2："<<s2.m_age<<endl;

    //******隐式调用*************
    Student s3=s1; //等价于Student s3=Student(s1); 
    cout<<"姓名3："<<s2.m_name<<endl;
    cout<<"年龄3："<<s2.m_age<<endl;
    
    return 0;
}

输出结果：