（一）C++面向对象三大特性：封装、继承、多态

C++认为万物都为对象，对象有属性和行为

类中的属性和行为，统一称为成员
属性—成员属性—成员变量
行为—成员函数—成员方法

#include <iostream>

using namespace std;

class Student
{
public:

    string Name;
    int Id;

    void PrintInfo()
    {
        cout<<"hello "<<Name<<"\n学号"<<Id<<endl;
    }
    void setName(string name)
    {
        Name=name;
    }
    void setId(int id)
    {
        Id=id;
    }
};

int main()
{
    Student student1;
    student1.Name="lvwencheng";
    student1.Id=12345;
    student1.PrintInfo();

    Student student2;
    student2.setName("caigou");
    student2.setId(22222);
    student2.PrintInfo();

    return 0;
}

输出

hello lvwencheng
学号12345
hello caigou
学号22222

（二）封装：访问权限

public
公共权限
成员类内可以访问，成员类外可以访问
protected
保护权限
成员类内可以访问，成员类外不可以访问
继承后子类可以访问父类属性
private
私有权限
成员类内可以访问，成员类外不可以访问
继承后子类不可以访问父类属性

（三）C++中class和struct的区别：

struct默认权限为公共权限
class默认权限为私有权限

（四）成员属性设置为私有

成员属性设置为私有，可以自己控制读写权限
对于写权限，我们可以检测到数据的有效性

#include <iostream>

using namespace std;

class Person
{
private:
    string Name;
    int Age;

public:
    void setName(string name)
    {
        Name=name;
    }
    string getName()
    {
        return Name;
    }
    void setAge(int age)
    {
        Age=age;
    }
    int getAge()
    {
        return Age;
    }
};

int main()
{   
    Person p1;
    p1.setName("lvwencheng");
 
    cout<<"hello world"<<p1.getName()<<endl;

    return 0;
}

（五）对象特性

对象初始化和清理：构造函数和析构函数

构造函数语法：

构造函数没有返回值，也没有void
函数名称与类名相同
构造函数有参数可以发生重载
程序在调用对象时会自动调用构造函数，无需手动调用，而且只调用一次

析构函数语法：

析构函数没有返回值，也没有void
函数名称与类名相同，在其名称前加～
析构函数不可以有参数，因此不可以发生重载
程序在销毁对象时会自动调用构造函数，无需手动调用，而且只调用一次

构造函数分类

按参数分：有参构造，无参构造
按类型分：普通构造，拷贝构造

拷贝构造函数调用时机

使用一个已经初始化完毕的对象创建一个新的对象。
值传递的方式给函数参数赋值
以值方式返回局部对象

#include <iostream>

using namespace std;

class Person
{
private:
    int Age;
public:
    Person()
    {
        cout<<"无参构造函数的调用"<<endl;
    }
    Person(int age)         
    {
        cout<<"有参构造函数的调用"<<endl;
        Age=age;
    }
    Person(const Person &p)
    {
        cout<<"拷贝构造函数的调用"<<endl;
        Age=p.Age;
    }

    ~Person()
    {
        cout<<"析构函数的调用"<<endl;
    } 

    int getAge()
    {
        return Age;
    }
};


int main()
{   
    //括号法
    Person p1(50);
    Person p2(p1);

    //显示法
    Person p3=Person(60);
    Person p4=Person(p3);
    //Person(60)匿名对象
    //不要利用拷贝构造函数初始化匿名对象

    //隐式转换法
    Person p5=70;
    Person p6=p5;

    cout<<"hello world  "<<p1.getAge()<<endl;
    cout<<"hello world  "<<p2.getAge()<<endl;
    cout<<"hello world  "<<p3.getAge()<<endl;
    cout<<"hello world  "<<p4.getAge()<<endl;
    cout<<"hello world  "<<p5.getAge()<<endl;
    cout<<"hello world  "<<p6.getAge()<<endl;

    return 0;
}

有参构造函数的调用
拷贝构造函数的调用
有参构造函数的调用
拷贝构造函数的调用
有参构造函数的调用
拷贝构造函数的调用
hello world  50
hello world  50
hello world  60
hello world  60
hello world  70
hello world  70
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用
析构函数的调用

初始化列表

Person(int a,int b)：m_A(a),m_B(b)
{
}

静态成员变量和静态成员函数

静态成员变量

访问方式：通过对象进行访问，通过类名进行访问

Person::Age

所有对象共享一份数据
编译阶段分配内存
类内声明，类外初始化

静态成员函数