C++基础-4-封装（构造函数与析构函数，深拷贝与浅拷贝，静态成员，this，友元，const修饰成员函数）

4. 封装

4.1.1 封装的意义

#include<iostream>
#include<string>
using namespace std;

const double PI = 3.14;

//设计一个圆类，求圆的周长
//周长公式：2*PI*半径

class Circle {
    //公共权限
public:
    // 属性
    int m_r;

    //行为，一般为函数
    double calZC() {
        return 2 * PI * m_r;
    }

};

//设计一个学生类，属性有学号和姓名；
//给学生姓名和学号赋值，并显示学号和姓名

class Student {
public:
    string m_Name;
    int m_ID;

    void showStu() {
        cout << "学生姓名：" << m_Name << " 学生学号：" << m_ID << endl;

    }

    void setName(string name) {
        m_Name = name;
    }

    void setID(int id) {
        m_ID = id;
    }

};


class Person {
public: //公共权限，累内内类都可访问
    string m_Name;

protected: //保护权限，类内可以访问，类外不能访问
    string m_Car;

private:  //私有权限，类内可以访问，类外不能访问
    int password;

/// <summary>
///在继承中， 保护权限子代可以访问，私有权限子代不可以访问；
/// </summary>
public:
    void func() {
        m_Name = "张三";
        m_Car = "奔驰";
        password = 123;
    }
};


int main() {

    //通过圆类创建具体的圆（对象）
    //Circle cl;
    //cl.m_r = 10;
    //cout << "圆的周长为：" << cl.calZC() << endl;

    //Student stu1;
    ////stu1.m_Name = "小明";
    //stu1.setName("小明");
    ////stu1.m_ID = 123123;
    //stu1.setID(123321);
    //stu1.showStu();

    //Student stu2;
    //stu2.m_Name = "张三";
    //stu2.m_ID = 2222;
    //stu2.showStu();

    Person p1;
    p1.func();
    cout << "Person 1的名字为：" << p1.m_Name << endl;



    system("pause");

    return 0;
}

//总结
//了解class的建立、三种权限；
//区分class与struct的区别：
//默认的访问权限不同，struct默认权限为公共权限，class默认为私有权限
//

 

4.1.2 成员属性私有化

#include<iostream>
using namespace std;
#include<string>

//成员属性私有化
//1.自己控制读写权限
//2.检测数据的有效性

class Person {
public:
    //写姓名
    void setName(string name) {
        m_Name = name;
    }
    //获取姓名
    string getName() {
        return m_Name;
    }

    //获取年龄
    int getAge() {
        //m_Age = 10;
        return m_Age;
    }

    void setAge(int age) {
        if (age < 0 || age > 150) {
            m_Age = 0;
            cout << "设置年龄有误！" << endl;
            return;
        }
        m_Age = age;
    }


private:
    string m_Name; //可读可写
    int m_Age;  //可读

};


int main() {

    Person p1;
    p1.setName("张三");
    cout << p1.getName() << endl;

    p1.setAge(1000);
    cout << p1.getAge() << endl;

    p1.setAge(15);
    cout << p1.getAge() << endl;

    system("pause");

    return 0;
}

//总结
//将成员属性私有化，可以自己控制读写的权限
//对于“写权限”，可以检测数据的有效性

 

4.2.1 构造函数与析构函数

#include<iostream>
using namespace std;

//对象初始化和清理
class Person {
public:
    //构造函数
    Person() {
        cout << "Person的构造函数！" << endl;
    }

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

};


void test01() {
    Person p1; //局部变量，在栈区，test01执行完后释放这个对象；
}


int main() {

    test01();

    system("pause");

    return 0;
}

//总结
//构造函数：
// 作用：初始化，成员属性赋值
// 语法： 类名(){}
// 没有返回值，也不写void
// 可以有参数，可以发生重载
// 自动调用，无需手动，只调一次
// 
//析构函数：
// 作用：清零，对象销毁前，系统自动调用，执行清理工作
// 语法： ~类名(){}
// 不能有参数，不能发生函数重载
// 自动调用，无需手动，只调一次
//
//构造函数与析构函数是必须有的实现，如果我们不写，编译器自动提供空实现的构造和析构

 

4.2.2 构造函数的分类与调用

#include<iostream>
using namespace std;

class Person {
public:
    Person() {
        cout << "Person的无参构造函数（默认构造函数）！" << endl;
    }

    Person(int a) {
        age = a;
        cout << "Person的有参构造函数！" << endl;
    }

    //拷贝构造函数(记住写法！)
    Person(const Person &p) {
        //将传入的所有属性，拷贝到当前;
        age = p.age;
        cout << "Person的拷贝构造函数！" << endl;
    }


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

    int age;
};

//调用
void test01() {
    //1.括号法

    //Person p1; // Percon的默认构造法函数，不加()
    //Person p2(10); // 有参构造
    //Person p3(p2); // 拷贝构造

    ////注意：
    ////调用默认构造函数时，不要加()
    //cout << "p2的年龄为：" << p2.age << endl;
    //cout << "p3的年龄为：" << p3.age << endl;


    //2.显示法
    //Person p1;
    //Person p2 = Person(10);  //有参构造
    //Person p3 = Person(p2);  //拷贝构造

    //Person(10); //匿名对象  特点：当前行执行结束后，系统会立即回收匿名对象；
    ////注意：
    ////不要利用拷贝构造函数来初始化匿名对象，编译器会认为这是个声明；
    ////Person(p3);  //报错

    //3.隐式转换法

    Person p4 = 10; //相当于 Person p4 = Person(10);
    Person p5 = p4; // 拷贝构造


}


int main() {

    test01();

    system("pause");

    return 0;
}

//总结
//分类：有参/无参；普通/拷贝
//调用：括号法/显示法/隐士转换法
//
//

 

4.2.3 拷贝构造函数的调用时机

#include<iostream>
using namespace std;

class Person {
public:
    Person() {
        cout << "Person的无参构造函数！" << endl;
    }

    Person(int a) {
        m_Age = a;
        cout << "Person的有参构造函数！" << endl;
    }

    Person(const Person& p) {
        m_Age = p.m_Age;
        cout << "Person的拷贝构造函数！" << endl;
    }

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

    int m_Age;

};

// 1.使用已经创建完的对象来初始化一个新对象
void test01() {
    Person p1(20);
    Person p2(p1);
    cout << "p2的年龄为：" << p2.m_Age << endl;
}

//2.值传递的方式给函数参数传值
void doWork(Person p) {

}

void test02() {
    Person p;
    doWork(p);
}

//3.以值方式返回局部对象，返回的是一个新对象

Person doWork2() {
    Person p1;
    return p1;
}

void test03() {
    Person p = doWork2();
}

int main() {

    //test01();
    //test02();
    test03();

    system("pause");

    return 0;
}


//总结
// 1.使用已经创建完的对象来初始化一个新对象
// 2.值传递的方式给函数参数传值
// 3.以值方式返回局部对象
//

 

4.2.4 构造函数的调用规则

#include<iostream>
using namespace std;

class Person {
public:
    Person() {
        cout << "Person的无参构造函数！" << endl;
    }

    Person(int a) {
        m_Age = a;
        cout << "Person的有参构造函数！" << endl;
    }

    Person(const Person& p) {
        m_Age = p.m_Age;
        cout << "Person的拷贝构造函数！" << endl;
    }

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

    int m_Age;

};

void test01() {
    Person p1;
    p1.m_Age = 18;

    Person p2(p1);
    cout << "p2的年龄为：" << p2.m_Age << endl;


}

int main() {

    test01();

    system("pause");

    return 0;
}

//总结
//C++默认给一个类添加三个函数：
//默认构造函数/默认析构函数/默认拷贝构造函数
//

 

4.2.5 深拷贝与浅拷贝

#include<iostream>
using namespace std;

class Person {
public:
    Person() {
        cout << "Person的无参构造函数！" << endl;
    }

    Person(int age, int height) {
        m_Age = age;
        m_Height = new int(height);  //创建堆区数据

        cout << "Person的有参构造函数！" << endl;
    }

    //有参考构造函数，通过初始化列表实现
    Person(int age, int num): m_Age(age), m_Num(num)
    {
        //m_Age = age;
        //m_Height = new int(height);  //创建堆区数据

        cout << "Person的有参构造函数！" << endl;
    }


    Person(const Person& p) {
        m_Age = p.m_Age;
        //m_Height = p.m_Height; //编译器默认实现这行代码
        //这行代码为浅拷贝，会导致堆区内存重复释放，程序报错

        //利用深拷贝解决，重新开辟堆区空间
        m_Height = new int(*p.m_Height);

        cout << "Person的拷贝构造函数！" << endl;
    }

    ~Person() {
        //析构代码，将堆区数据释放干净;
        if (m_Height != NULL)
        {
            delete m_Height;
            m_Height = NULL;
        }

        //浅拷贝带来的问题：堆区数据重复释放,
        //使用深拷贝方法解决


        cout << "Person的析构函数！" << endl;
    }

    int m_Age;
    int m_Num;
    int *m_Height;
};

void test01() {

    Person p1(18, 160);
    cout << "p1的年龄为：" << p1.m_Age << endl;
    cout << "p1的身高为：" << *p1.m_Height << endl;

    Person p2(p1);

    cout << "p2的年龄为：" << p2.m_Age << endl;
    cout << "p2的身高为：" << *p2.m_Height << endl;

}

int main() {

    test01();

    system("pause");

    return 0;
}


//总结
//浅拷贝：简单的赋值拷贝操作
//深拷贝：在堆区重新申请空间，进行拷贝操作
//如果属性中有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题
//
// 其他结论
// 当其他类对象作为本类成员时。构造函数先构造对象，再构造自身，析构的顺序与构造相反
//

 

4.2.6 静态成员

#include<iostream>
using namespace std;

class Person {
public:
    
    static int a; //静态成员变量，类内声明
    int b; //非静态成员变量
    static void func()
    {
        a = 100; //静态成员函数可以访问静态成员变量，共享的
        cout << "静态成员函数" << endl;
        cout << "静态成员变量a的值为：" << a << endl;
        //b = 200; //报错，静态成员函数不能访问非静态成员变量；无法区分是哪个对象的b
    }

    //静态成员函数也是有访问权限的
private:
    static void func1() {
        cout << "私有的静态成员函数" << endl;
    }

};

int Person::a = 10; //类外初始化

void test01() {
    //1.通过对象访问
    Person p;
    p.func();

    //2.通过类名访问
    Person::func();

}

int main() {

    test01();

    system("pause");

    return 0;
}


// 总结
// 成员属性与成员函数加入static关键字，变为静态成员
// 
// 静态成员：
// 1.所有对象共享同一份数据
// 2.在编译阶段分配内存
// 3.类内声明，类外初始化
// 
// 静态成员函数：
// 1.所有对象共享同一个函数
// 2.静态成员函数只能访问静态成员变量（重）
// 
// 

 

4.3.1 成员变量和成员函数分开存储

#include<iostream>
using namespace std;

//类内的成员变量和成员函数分开储存

class Person {
    int m_A; //非静态成员变量，属于类的对象上
    static int m_B;  //静态成员变量，不属于类的对象上

    void func() {  //非静态成员函数，不属于类的对象上

    }
    static void func2() {  //静态成员函数，不属于类的对象上

    }

};

int Person::m_B = 0;


void test01() {
    Person p;
    //空对象占用内存空间为：1
    //C++编译器为每个空对象分配一个字节空间，是为了区分空对象占用内存的位置
    //每个空对象也应该有一个独一无二的内存地址
    cout << "size of p = " << sizeof(p) << endl;
}

void test02() {
    Person p;
    cout << "size of p = " << sizeof(p) << endl;
}

int main() {

    //test01();

    test02();

    system("pause");

    return 0;
}


//总结
//在C++中，类内的成员变量和成员函数分开储存
//只有非静态成员变量才属于类的对象
//

 

4.3.2 this指针

#include<iostream>
using namespace std;


class Person {
public:
    Person(int age) {

        //age = age; //名称冲突
        //this指针指向的是被调用成员函数所属的对象
        this->age = age;  //通过this来解决
        
    }

    Person& PersonAddAge(Person& p) {  //返回p2本体，需要用引用的方式返回
        this->age += p.age;

        //this指向p2的指针，而*this指向的就是p2这个对象的本体；
        return *this;
    }

    int age;

};

void test01() {
    Person p1(10);
    cout << "p1的年龄为：" << p1.age << endl;

    //链式编程思想
    Person p2(20);
    p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
    cout << "p2的年龄为：" << p2.age << endl;

}

int main() {

    test01();

    system("pause");

    return 0;
}

// 总结
// 已知：
//        成员函数与成员变量分开存储
//        每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会公用一块代码
//        那么问题是：这一块代码是如何区分哪个对象在调用自己呢？
// 
//        C++通过特殊的指针对象，this指针，解决上述问题
//        this指针指向被调用的成员函数所属的对象
// 
// this指针是隐含每一个非静态成员函数的一种指针
// this指针不需要定义，直接使用即可
// 
// this指针的用途：
//        当形参和成员变量同名时，可以用this指针做区分
//        在类的非静态成员函数中返回对象本身，可以使用 return *this
// 
// 
// 其他结论
// C++中空指针也可以调用成员函数，但是需要注意有没有用到this指针
// 如果用到了this指针，需要加以判断，保证代码的健壮性
// if(this == NULL){
//     return;
// }
//

 

4.3.3 const修饰成员函数

#include<iostream>
using namespace std;


class Person {
public:
    Person() {
        cout << "Person的无参构造函数！" << endl;
    }

    Person(int a) {
        cout << "Person的有参构造函数！" << endl;
    }

    void showPerson() const
    {
        //this指针的本质 是 指针常量 指针的指向不可以修改
        // 在成员函数后加const，修饰的是this指向，让指针指向的值也不可以修改
        //m_A = 100;  //加入const后，变为常函数，常函数不能修改成员属性
        //this->m_A = 100;  //本质
        this->m_B = 100;  //加入mutable后可以修改

    }

    void func() {

    }

    int m_A;
    mutable int m_B;

};

void test01() {
    Person p1;
    p1.showPerson();

    const Person p2;  //在对象前加入const，变为常对象
    //p2.m_A = 100; //报错，指针的属性不可修改
    p2.m_B = 100;

    //常对象只能调用常函数

    p2.showPerson(); //可以调用常函数
    //p2.func(); //常对象 不可以调用普通成员函数，因为普通成员函数可以修改属性

}

int main() {

    test01();

    system("pause");

    return 0;
}

// 总结
// const修饰成员函数
// 常函数：
//        成员函数后加const，成为常函数
//        常函数内不可以修改成员属性；
//        成员属性声明时加关键字mutable后，在常函数中就可以修改了
// 
// 常对象：
//        声明对象前加入const称该对象为常对象
//        常对象只能调用常函数
// 
// 
// 

 

4.4.1 友元

#include<iostream>
using namespace std;

//建筑物类
class Building {
    //goodGay 全局函数是building好朋友，可以访问building的私有成员
    friend void goodGay(Building* building);

public:
    Building() {
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
    }
public:
    string m_SittingRoom; //客厅

private:
    string m_BedRoom; //卧室
};

void goodGay(Building* building) {
    cout << "好基友全局函数 正在访问：" << building->m_SittingRoom << endl;
    cout << "好基友全局函数 正在访问：" << building->m_BedRoom << endl;
}



void test01() {
    Building building;
    goodGay(&building);
}



int main() {

    test01();

    system("pause");

    return 0;
}


// 总结
// 友元，关键字friend
// 全局函数做友元
// 类做友元
// 成员函数做友元
// 
// 

 

参考《黑马程序员》C++教程