C++核心编程

本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。

1.内存分区模型

C++程序在执行时，将内存大方向划分为4个区域

• 代码区：存放函数体的二进制代码，由操作系统进行管理
• 全局区：存放全局变量和静态变量以及常量
• 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
• 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

内存分区的意义：不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程性

1.1程序运行前

在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域

代码区：

存放CPU执行的机器指令

代码是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可

代码是只读的，使其只读的原因是防止程序意外的修改了它的指令

全局区：

全局变量、静态变量、全局常量、字符串常量存放在全局区

局部变量、局部常量不在全局区

该区域的数据在程序结束后由操作系统释放

static 修饰的叫静态，const 修饰的叫常量

1.2程序运行后

栈区：

由编译器自动分配释放，存放函数的参数值（形参）和局部变量

注意：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

​x
1
int* func()
2
{
3
    int a = 10;
4
    return &a;                       //返回局部变量的地址，存放在栈区，栈区的数据在函数执行完自动释放
5
}
6

7
int main()
8
{
9
    int *p = func();                 //指针接收返回的地址
10
    cout << *p << endl;              //解引用，理论上是拿不到10的
11
    cout << *p << endl;              //就算上面能拿到10，也是编译器一次短暂的保留，保留是不会一直持续下去的
12
    system("pause");
13
    return 0;
14
}

堆区：

由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

xxxxxxxxxx
17
1
int* func()
2
{
3
    //利用new关键字，可以将数据开辟到堆区
4
    //这里的指针本质上也是局部变量，它是放在栈区的，函数调用结束后就释放掉
5
    int *p = new int(10);
6
    return p;
7
}
8

9
int main()
10
{
11
    int *p = func(); 
12
    
13
    cout << *p << endl;
14
    cout << *p << endl;
15
    system("pause");
16
    return 0;
17
}

1.3new操作符

C++中利用new操作符在堆区开辟数据

利用new创建的数据，会返回该数据对应的类型的指针

基本语法如下：

xxxxxxxxxx
11
1
//利用new创建整型数据
2
int *p = new int(10);          //这里小括号里的10是数据的初始值
3
delete p;                      //释放
4

5
//利用new开辟一个整型数组
6
int *p = new int[10];          //这里中括号里的10是开辟数组的长度,开辟的数组没有初始值，需进行赋值操作
7
for(i=0;i<10;i++)
8
{
9
    p[i] = i;
10
}
11
delete[] p;                    //释放数组的时候要加一个中括号[]

2.引用

2.1引用的基本使用

作用：给变量起别名

语法：数据类型 &别名 = 原名；

示例如下：

xxxxxxxxxx
10
1
int main()
2
{
3
    int a = 10;
4
    int &b = a;                      //创建引用
5
    
6
    b = 100;
7
    cout << "a = " << a << endl;
8
    cout << "b = " << b << endl;     //此时对b操作就是对a操作，相当于两个捆绑在一起，值保持一致   
9
    
10
}

2.2引用的注意事项

1. 引用必须初始化
2. 引用在初始化后不允许更改

2.3引用做函数参数

以前学过两种交换函数的写法，分别是值传递和地址传递，但是值传递仅仅是形参的交换，它无法影响实参，故使用地址传递，现在用引用的方法也可以实现和地址传递同样的效果。示例如下：

xxxxxxxxxx
40
1
//值传递
2
void Swap01(int a,int b)
3
{
4
    int temp = a;
5
    a = b;
6
    b = temp;
7
}
8

9
//地址传递
10
void Swap02(int *a,int *b)
11
{
12
    int temp = *a;
13
    *a = *b;
14
    *b = temp;
15
}
16
//引用传递
17
void Swap03(int &a,int &b)           //别名也可以和原名一样
18
{
19
    int temp = a;
20
    a = b;
21
    b = temp;
22
}
23

24
int main()
25
{
26
    int a = 10;
27
    int b = 20;
28
    
29
    //值传递调用
30
    Swap01(a,b);
31
    
32
    //地址传递调用
33
    Swap02(&a,&b);
34
    
35
    //引用传递调用
36
    Swap03(a,b);
37
    
38
    system("pause");
39
    return 0;
40
}

2.4引用做函数的返回值

1.不要返回局部变量的引用。

2.函数调用可作为左值。

示例如下：

xxxxxxxxxx
13
1
int& test01()
2
{
3
    int a = 10;    //局部变量存放在四区中的栈区，在函数调用完之后会被释放
4
    return a;
5
}
6

7
int main()
8
{
9
    int &ref = test01();
10
    cout << "ref = " << ref << endl;      //第一次结果正确，是因为编译器做了一次保留
11
    cout << "ref = " << ref << endl;      //第二次结果错误，因为a的内存已经被释放
12
    
13
}

xxxxxxxxxx
17
1
int& test02()
2
{
3
    static int a = 10;                   //静态变量存放在全局区，全局区上的数据在程序结束后系统释放
4
    return a;
5
}
6

7
int main()
8
{
9
    int &ref2 = test02();
10
    
11
    cout << "ref2 = " << ref2 << endl;
12
    cout << "ref2 = " << ref2 << endl;  //静态变量不会释放
13
    
14
    test02() = 1000;
15
    cout << "ref2 = " << ref2 << endl;
16
    cout << "ref2 = " << ref2 << endl;  //如果函数的返回值是引用，那么这个函数调用可作为左值
17
}

2.5引用的本质

本质：引用的本质在C++内部实现是一个指针常量

xxxxxxxxxx
10
1
int main()
2
{
3
    int a = 10;
4
    
5
    //自动转换为int * const ref = &a;指针常量是指针指向不可改变，也说明了引用为什么不可更改 
6
    int &ref = a;
7
    //内部发现ref是引用，自动帮我们转换为：*ref = 20;
8
    ref = 20;
9
    
10
}

结论：C++推荐用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了

2.6常量引用

作用：常量引用主要用于修饰形参，防止误操作

在函数形参列表中，可以加const修饰形参，防止形参改变实参

示例如下：

xxxxxxxxxx
23
1
//引用使用场景，通常用来修饰形参
2
void showvalue(const int& v)
3
{
4
    //v = 20; 会报错！表达式左边必须为可修改的左值。这样做可以防止误操作，在一些只读性的函数调用中，防止形参影响实参
5
    cout << v << endl;
6
}
7

8
int mian()
9
{
10
    //int& ref = 10;引用本身需要一个合法的内存空间，表达式右边必须为一个变量，比如a，因此这行错误
11
    //加入const就可以了，编译器优化代码，int temp = 10; const int & ref = temp;
12
    const int & ref = 10;
13
    
14
    //ref = 100; //加入const后不可以修改变量
15
    cout << ref << endl;
16
    
17
    //函数中利用常量引用防止误操作修改实参
18
    int a = 10;
19
    showvalue(a);
20
    
21
    system("pause");
22
    return 0;
23
}

3.函数提高

3.1函数的默认参数

在C++中，函数的形参列表的形参是可以有默认值的。

语法：返回值类型 函数名 (参数 = 默认值) {}

如果我们自己传入数据，就用我们自己的数据，否则就用默认值

注意事项：

1.如果某个位置参数有默认值，那么从这个位置往后，从左到右，必须都要有默认值

2.如果函数声明有默认值，函数实现的时候就不能有默认参数，声明和实现只能有一个有默认参数

xxxxxxxxxx
12
1
//1.如果某个位置参数有默认值，那么从这个位置往后，从左到右，必须都要有默认值
2
int func(int a ,int b = 10, int c = 10)
3
{
4
    return a + b + c;
5
}
6

7
//2.如果函数声明有默认值，函数实现的时候就不能有默认参数，声明和实现只能有一个有默认参数
8
int func2(int a = 10 ;int b = 10);
9
int func2(int a ,int b)
10
{
11
    return a + b;
12
}

3.2函数占用参数

C++中函数的形参列表中可以有占位参数，用来作占位，调用函数时必须填补该位置

语法：返回值类型 函数名 (数据类型) {}

在现阶段中占位参数存在的意义不大，但是在后面的学习中会用到该技术

示例如下：

xxxxxxxxxx
13
1
//函数占位参数，占位参数也可以有默认参数
2
void func(int a ,int = 10)        //对!这里没有写错，就是int = 10，当然这里也可以只写一个数据类型int
3
{
4
    cout << "This is a func!" << endl;
5
}
6

7
int main()
8
{
9
    func(10 ,10);        //占位参数必须填补，当然有默认参数的时候可以不用填补\
10
    
11
    system("pause");
12
    return 0;
13
}

3.3函数的重载

3.3.1函数重载概述

作用：函数名可以相同，提高复用性

函数重载满足条件：

• 同一个作用域下
• 函数名称相同
• 函数参数类型不同、或者个数不同、或者顺序不同

注意：函数的返回值不可以作为函数重载的条件

示例如下：

xxxxxxxxxx
40
1
//函数重载需要函数在同一个作用域下，这里都是全局作用域
2
void func()
3
{
4
    cout << "func()的调用！" << endl;
5
}
6
void func(int a)
7
{
8
    cout << "func(int a)的调用！" << endl;
9
}
10
void func(double a)
11
{
12
    cout << "func(double a)的调用！" << endl;
13
}
14
void func(int a ,double b)
15
{
16
    cout << "func(int a ,double b)的调用！" << endl;
17
}
18
void func(double a ,int b)
19
{
20
    cout << "func(double a ,int b)的调用！" << endl;
21
}
22

23
//函数返回值不可以作为函数重载的条件
24
//int func(double a ,int b)
25
//{
26
//    cout << "func(double a ,int b)的调用！" << endl;
27
//}
28

29

30
int main()
31
{
32
    func();
33
    func(10);
34
    func(3.14);
35
    func(10,3.14);
36
    func(3.14,10);
37
    
38
    system("pause");
39
    return 0;
40
}

3.3.2函数重载的注意事项

• 引用作为重载条件
• 函数重载碰到函数默认参数，有时候出现歧义报错，要尽量避免这种情况

示例如下：

xxxxxxxxxx
23
1
//函数重载注意事项
2
//1.引用作为重载条件
3

4
void func(int &a)
5
{
6
    cout << "func(int &a)的调用！" << endl;
7
}
8

9
void func(const int &a)
10
{
11
    cout << "func(const int &a)的调用！" << endl;
12
}
13

14
int main()
15
{
16
    int a = 10;
17
    
18
    func(a);              //调用的是上面那个
19
    func(10);             //调用的是下面那个
20
    
21
    system("pause");
22
    return 0;
23
}

xxxxxxxxxx
20
1
//2.函数重载碰到函数默认参数
2

3
void func2(int a ,int b = 10)
4
{
5
    cout << "func2(int a ,int b = 10)的调用！" << endl;
6
}
7

8
void func2(int a)
9
{
10
    cout << "func2(int a)的调用！" << endl;
11
}
12

13
int main()
14
{
15
    func2(10);                    //产生歧义，不知道该调用哪个啦！
16
    func2(10,20);                 //不会产生歧义，调用上面那个
17
    
18
    system("pause");
19
    return 0;
20
}

4.类和对象

C++面向对象的三大特性为：封装、继承、多态

C++认为万事万物皆为对象，对象有其属性和行为

4.1封装

4.1.1封装的意义

封装是C++面向对象三大特性之一，封装的意义：

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制

语法为：class 类名{访问权限:属性/行为}

示例：写一个圆类，并求出圆的周长

xxxxxxxxxx
29
1
//圆周率
2
const double PI = 3.14;
3

4
class Circle
5
{
6
public:             //访问权限为公共的权限
7
    //属性
8
    int m_r;        //半径
9
    
10
    //行为
11
    //获取圆的周长
12
    double calculateZC()
13
    {
14
        return 2 * PI * m_r;
15
    }
16
};
17

18
int main()
19
{
20
    //通过圆类，创建圆的对象
21
    //c1就是一个具体的圆
22
    Circle c1;
23
    c1.m_r = 10;      //给圆对象的半径进行赋值操作
24
    
25
    cout << "圆的周长为：" << c1.calculateZC() << endl;
26
    
27
    system("pause");
28
    return 0;
29
}

示例：创建一个学生类

xxxxxxxxxx
36
1
#include <string>          //使用字符串时需要
2

3
class Student{
4
public:
5
    //属性
6
    string m_name;
7
    int m_id;
8
    
9
    //行为
10
    void setname(string name)
11
    {
12
        m_name = name;
13
    }
14
    
15
    void setid(int id)
16
    {
17
        m_id = id;
18
    }
19
    
20
    void showStudent()
21
    {
22
        cout << "姓名：" << m_name << "学号：" << m_id << endl;
23
    }
24
};
25

26
int main()
27
{
28
    Student s1;
29
    s1.setname("张三");
30
    s1.setid(9527);
31
    
32
    s1.showStudent();
33
    
34
    system("pause");
35
    return 0;
36
}

访问权限有三种：

1. public 公共权限 类内可以访问，类外也可以访问
2. protected 保护权限 类内可以访问，类外不可以访问 儿子可以访问父亲中的保护内容
3. private 私有权限 类内可以访问，类外不可以访问 儿子不可以访问父亲中的私有内容

示例如下：

xxxxxxxxxx
29
1
class Person{
2
public:
3
    string m_name;                  //姓名 公共权限
4
    
5
protected:
6
    string m_car;                   //汽车 保护权限
7
    
8
private:
9
    int m_password;                 //银行卡密码 私有权限
10
    
11
public:
12
    void func()
13
    {
14
        m_name = "张三";
15
        m_car = "拖拉机";
16
        m_password = 8940886;
17
    }
18
};
19

20
int main()
21
{
22
    Person p1;
23
    p1.m_name = "李四";     //这是可以成功的，因为m_name的权限为public
24
    //p1.m_car = "奔驰";保护权限类外访问不到
25
    //p1.m_password = "1234567";私有权限，类外访问不到
26
    
27
    system("pause");
28
    return 0;
29
}

不论是属性还是行为，都要遵守权限规则，定义在protected和private下的行为（函数/方法）同样无法在类外访问到。

4.1.2 struct和class的区别

在C++中struct和class的唯一区别就在于默认的访问权限不同：

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

4.1.3成员属性设置为私有

优点：

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

示例如下：

xxxxxxxxxx
43
1
#include <string>
2

3
class Person{
4
private:
5
    string m_name;
6
    int age;
7
public:
8
    //通过这个接口，可以在类外间接设置私有属性
9
    void setname(string name)
10
    {
11
        m_name = name;
12
    }
13
    //通过这个接口，可以在类外访问到属性
14
    string getname()
15
    {
16
        return m_name;
17
    }
18
    
19
    //对于写权限，我们可以检测数据的有效性
20
    void setage(int age)
21
    {
22
        if(age < 0 || age >100)
23
        {
24
            m_age = 0;          //给默认值
25
            cout << "你这个输入的年龄不太合理！" << endl;
26
        }
27
        m_age = age;
28
    }
29
};
30

31
int main()
32
{
33
    Person p;
34
    //p.m_name = "张三";是会报错的，因为m_name为私有访问权限
35
    p.setname("张三");
36
    //cout << "姓名：" << p.m_name << endl;同样也会报错
37
    cout << "姓名" << p.getname() << endl;
38
    
39
    p.setage(18);                 //设置年龄
40
    
41
    system("pause");
42
    return 0;
43
}

4.2对象的初始化和清理

4.2.1构造函数和析构函数

对象的初始化和清理是两个非常重要的安全问题

一个对象或者变量没有初始状态，对其使用的后果是未知的。

同样的使用完一个对象或者变量，没有及时清理，也会造成一定的安全问题。

C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象的初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供，并且编译器提供的构造函数和析构函数是空实现。

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用。
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名 () {}

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

析构函数语法：~类名 () {}

1. 析构函数，没有返回值也不写void
2. 函数名称与类名相同，在名称前加上符号~
3. 析构函数不可以有参数，因此不可以发生重载
4. 程序在对象销毁前自动调用析构，无需手动调用，且只调用一次

xxxxxxxxxx
26
1
class Person{
2
public:
3
    Person()
4
    {
5
        cout << "Person的构造函数调用" << endl;
6
    }
7
    ~Person()
8
    {
9
        cout << "Person的析构函数调用" << endl;
10
    }
11
};
12

13
void func()
14
{
15
    Person p;
16
}
17

18
int main()
19
{
20
    func();            //构造和析构都会调用，因为子函数里的对象在栈区，函数调用结束后会自动释放，释放的时候调用析构
21
    
22
    Person p;          //这是主函数里面创建一个对象，就只会调用构造函数，而析构函数不会被调用
23
    
24
    system("pause");
25
    return 0;
26
}

4.2.2构造函数的分类及调用

两种分类方式：

按参数分为：有参构造和无参构造

按类型分为：普通构造和拷贝构造

三种调用方式： 括号法、显示法、隐式转换法

示例如下：

xxxxxxxxxx
43
1
class Person{
2
public:
3
    Person()
4
    {
5
        cout << "无参构造函数！" << endl;
6
    }
7
    Person(int a)
8
    {
9
        age = a;
10
        cout << "有参构造函数！" << endl;
11
    }
12
    Person(const Person &p)
13
    {
14
        age = p.age;
15
        cout << "拷贝构造函数！" << endl;
16
    }
17
    
18
    ~Person()
19
    {
20
        cout << "析构函数调用！" << endl;
21
    }
22
public:
23
    int age;
24
};
25

26
void test01()
27
{
28
    //括号法
29
    Person p1;         //无参构造函数
30
    Person p2(10);     //有参构造函数
31
    Person p3(p2);     //拷贝构造函数
32
    //注意的是无参构造不要加括号，比如：Person p1();这样编译器会认为这行代码是一个函数声明，而不是一个对象的创建
33
    
34
    //显示法
35
    Person p1;                  //无参构造函数
36
    Person p2 = Person (10);    //有参构造函数
37
    Person p3 = Person (p2);    //拷贝构造函数
38
    
39
    //隐式转换法
40
    Person p4 = 10;          //相当于写了 Person p4 = person (10); 编译器会隐式的转换
41
    Person p5 = p4;          //拷贝构造函数
42
    
43
}

括号法注意事项： Person p1(); 不要这样写，加了括号，编译器会认为这行代码是一个函数声明，而不是一个对象的创建。

显示法注意事项：

1.单独拿出等号右侧，Person (10)，这是一个匿名对象，它在执行完当前行后，系统会立即回收掉匿名对象。

2.不要利用拷贝构造函数，初始化匿名对象。Person (p3); 编译器会认为它等价于 Person p3，这样的话，由于上面也定义过p3，就会出现重定义的报错！

4.2.3拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况

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

示例如下：

xxxxxxxxxx
54
1
class Person{
2
public:
3
    Person()
4
    {
5
        cout << "无参构造函数！" << endl;
6
    }
7
    
8
    Person(int a)
9
    {
10
        age = a;
11
        cout << "有参构造函数！" << endl;
12
    }
13
    
14
    Person(const Person &p)
15
    {
16
        age = p.age;
17
        cout << "拷贝构造函数！" << endl;
18
    }
19
    
20
    ~Person()
21
    {
22
        cout << "析构函数调用！" << endl;
23
    }
24
public:
25
    int age;
26
};
27

28
void test01()
29
{
30
    Person p1(10);
31
    Person p2(p1);         //使用一个已经创建完毕的对象来初始化一个新的对象
32
    cout << "p2的年龄为：" << p2.age << endl;   //输出应该为10
33
}
34

35
void test02(Person p)     //值传递的方式给函数参数传值，会发生拷贝构造
36
{
37
    cout << "p的年龄为：" << p.age << endl;
38
}
39

40
//以值方式返回局部对象
41
Person doWork()
42
{
43
    Person p1;
44
    cout << (int*)&p1 << endl;
45
    return p1;
46
}
47
void test03()
48
{
49
    Person p = doWork();
50
    cout << (int*)&p << endl;
51
}
52

53
//调用test03()的运行结果为：先无参构造p1，然后打印对象p1的地址，return的时候先发生拷贝构造，再析构对象p1
54
//打印对象p的地址，析构对象p

4.2.4构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数体为空）
3. 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

• 如果用户定义有参构造函数，C++不再提供默认无参构造函数，但是会提供默认拷贝构造函数
• 如果用户定义拷贝构造函数，C++不会再提供其他普通构造函数

4.2.5深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间进行拷贝操作

示例如下：

xxxxxxxxxx
52
1
class Person{
2
public:
3
    Person()
4
    {
5
        cout << "无参构造函数！" << endl;
6
    }
7
    
8
    Person(int age,int height)
9
    {
10
        m_age = age;
11
        m_height = new int(height);
12
        
13
        cout << "有参构造函数！" << endl;
14
    }
15
    
16
    Person(const Person &p)
17
    {
18
        m_age = p.m_age;
19
        //m_height = p.m_height;            //编译器自带的浅拷贝操作
20
        m_height = new int(*p.m_height);    //自己写的拷贝构造函数，使用的是在堆区重新申请空间进行深拷贝操作
21
        
22
        //如果使用编译器自带的浅拷贝，会在析构的时候发生重复释放内存空间的问题
23
        cout << "拷贝构造函数！" << endl;
24
    }
25
    
26
    ~Person()
27
    {
28
        if(m_height != NULL)
29
        {
30
            delete m_height;
31
            m_height = NULL;
32
        }
33
        cout << "析构函数调用！" << endl;
34
    }
35
public:
36
    int m_age;
37
    int *m_height;
38
};
39

40
void test()
41
{
42
    Person p1(18,175);
43
    Person p2(p1);
44
}
45

46
int main()
47
{
48
    test();
49
    
50
    system("pause");
51
    return 0;
52
}

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来内存空间重复释放的问题。

4.2.6初始化列表

作用：C++提供了初始化列表语法，用来初始化属性

语法为：构造函数():属性1(值1),属性2(值2),属性3(值3)...{}

示例如下：

xxxxxxxxxx
16
1
class Person{
2
public:
3
    Person (int a,int b,int c) :m_A(a),m_B(b),m_C(c)
4
    {
5
        
6
    }
7
    
8
    int m_A;
9
    int m_B;
10
    int m_C;
11
};
12

13
void test()
14
{
15
    Person p(10,20,30);
16
}

4.2.7类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员。

当B类中有对象A作为成员，A和B的构造和析构的顺序谁先谁后？

xxxxxxxxxx
6
1
class A{};
2

3
class B{
4
public:
5
    A a;
6
};

构造顺序为：A先，B后

析构顺序为：B先，A后

4.2.8静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。

静态成员分为：

• 静态成员变量

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

• 静态成员函数

  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量

示例1：静态成员变量

xxxxxxxxxx
39
1
class Person{
2
public:
3
    static int m_A;        //静态成员变量
4
    
5
private:
6
    static int m_B;        //静态成员变量也是有访问权限的
7
    
8
};
9

10
//类内声明，类外初始化
11
int Person::m_A = 10;
12
int Person::m_B = 10;
13

14
void test01()
15
{
16
    //静态成员变量的两种访问方式
17
    //1.通过对象
18
    Person p1;
19
    p1.m_A = 100;
20
    cout << "p1.m_A = " << p1.m_A << endl;     //输出100
21
    
22
    Person p2;
23
    p2.m_A = 200;
24
    cout << "p1.m_A = " << p1.m_A << endl;
25
    cout << "p2.m_A = " << p2.m_A << endl;     //共享同一份数据，因此两行输出都是200
26
    
27
    //2.通过类名
28
    cout << "m_A = " << Person::m_A << endl;
29
    
30
    //cout << "m_B = " << Person::m_B << endl;  //私有权限访问不到
31
}
32

33
int main()
34
{
35
    text01();
36
    
37
    system("pause");
38
    return 0;
39
}

示例2：静态成员函数

xxxxxxxxxx
40
1
class Person{
2
public:
3
    static void func()
4
    {
5
        cout << "static void func()的调用" << endl;
6
        m_A = 100;
7
        //m_B = 200;错误，静态成员函数不可以访问非静态成员变量，静态成员函数只能访问静态成员变量
8
    }
9
     
10
    static int m_A;
11
    int m_B;
12
private:
13
    static void func2()
14
    {
15
        cout << "static void func2()的调用" << endl;
16
    }
17
};
18
int Person::m_A = 10;
19

20
void test01()
21
{
22
    //静态成员函数的两种访问方式
23
    //1.通过对象
24
    Person p1;
25
    p1.func();
26
    
27
    //2.通过类名
28
    Person::func();
29
    
30
    //Person::func2();  //私有权限访问不到
31
    
32
}
33

34
int main()
35
{
36
    text01();
37
    
38
    system("pause");
39
    return 0;
40
}

4.3C++对象模型和this指针

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

在C++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上，静态成员变量、非静态成员函数、静态成员函数都不属于类的对象上

空对象占用的内存空间为1个字节，C++编译器会给每个空对象分配1个字节空间，是为了区分空对象占内存的位置，每个空对象应该有一个独一无二的内存地址。

4.3.2this指针的概念

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

那么问题是：这一块代码是如何区分是哪个对象调用自己呢？

C++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针，this指针不需要定义，直接使用即可。

this指针的用途

• 当形参和成员变量同名时，可以用this指针来区分
• 在类的非静态成员函数中返回对象本身，可使用return *this

示例如下：

xxxxxxxxxx
25
1
class Person{
2
public:
3
    Person(int age)
4
    {
5
        //当形参和成员变量同名时，可以用this指针来区分
6
        this->age = age;      //写age = age;会由于无法区分形参和成员变量而出错！
7
    }
8
    
9
    Person& PersonAddPerson(Person p)  //如果这里&去掉的话，返回的是值，返回的不是p2的本体，而是拷贝出的新的数据
10
    {                                  //如果这里&去掉，后续输出应该是20
11
        this->age += p.age;
12
        return *this;
13
    }
14
    int age;
15
};
16

17
void test01()
18
{
19
    Person p1(10);
20
    cout << "p1.age" << p1.age << endl;
21
    
22
    Person p2(10);
23
    P2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);   //链式编程思想，应该输出40
24
    cout << "p2.age" << p2.age << endl;
25
}

4.3.3空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

示例如下：

xxxxxxxxxx
25
1
class Person{
2
public:
3
    void ShowClassName()
4
    {
5
        cout << "this is Person class" << endl;
6
    }
7
    void ShowPersonAge()
8
    {
9
        if(this == NULL)
10
        {
11
            return ;
12
        }
13
        //报错的原因是传入的this指针是空指针
14
        cout << "age = " << this->m_age << endl;
15
    }
16
    
17
    int m_age;
18
};
19

20
void test01()
21
{
22
    Person *p = NULL;
23
    p->ShowClassName();
24
    p->ShowPersonAge();          //如果没有if语句，程序会因为这行代码崩溃
25
}

4.3.4const修饰成员函数

常函数：

• 成员函数后加const，我们称这个函数为常函数
• 常函数内不可修改成员属性
• 成员属性声明时加关键字mutable，在常函数中依然可以修改

常对象：

• 声明对象前加const称该对象为常对象
• 常对象只能调用常函数

示例如下：

xxxxxxxxxx
31
1
class Person{
2
public:
3
    void showPerson() const
4
    {
5
        //m_a = 100;成员函数后面加上const后，就不能修改属性值了
6
        m_b = 100;     //因为成员属性声明时加关键字`mutable`，在常函数中依然可以修改
7
    }
8
    
9
    void func(){}
10
    
11
    int m_a;
12
    mutable int m_b;   //特殊变量，即使在常函数中也是可以修改值的
13
};
14

15
void test01()
16
{
17
    Person p;
18
    p.showPerson();
19
}
20

21
void test02()
22
{
23
    const Person p;     //在对象前加const，变为常对象
24
    //p.m_a = 100;      //报错，常对象的属性也是不允许修改的
25
    p.m_b = 100;        //特殊变量，在常对象下也可以修改
26
    
27
    //常对象只能调用常函数
28
    p.showPerson();     //允许
29
    //p.func();会报错，常对象只能调用常函数，因为在普通成员函数中是允许修改属性值的，这与常对象的准则不符
30
    
31
}

this指针的本质是一个指针常量，它的指向是不可以修改的，在成员函数后加const后，限定指针指向和指向的值都不可以修改了。

4.4友元

生活中你的家有客厅（public），有你的卧室（private）。客厅所有的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去，但是呢，你也可以允许你的好闺蜜好基友进去。

在程序里，有些私有属性也想让类外特殊的一些函数或者类访问，就需要用到友元技术，友元的目的就是让一个函数或者类访问另一个类中的私有成员

友元的关键字为friend

友元的三中实现

• 全局函数做友元
• 类做友元
• 成员函数做友元

4.4.1全局函数做友元

示例如下：

xxxxxxxxxx
37
1
class Building
2
{
3
    //告诉编译器goodgay全局函数是Building类的好朋友，可以访问类中的私有内容
4
    friend void goodgay(Building *building);
5
    
6
public:
7
    Building()
8
    {
9
        this->m_sittingroom = "客厅";
10
        this->m_bedroom = "卧室";
11
    }
12
public:
13
    string m_sittingroom;      //客厅
14
private:
15
    string m_bedroom;          //卧室
16
};
17

18
void goodgay(Building *building)
19
{
20
    cout << "好基友正在访问：" << building->m_sittingroom << endl;    //正常访问
21
    cout << "好基友正在访问：" << building->m_bedroom << endl;
22
    //没有类里面的友元声明，是不允许在类外访问私有属性的，下面这行代码会报错！
23
}
24

25
void test01()
26
{
27
    Building b;
28
    goodgay(&b);
29
}
30

31
int main()
32
{
33
    test01();
34
    
35
    system("pause");
36
    return 0;
37
}

4.4.2类做友元

示例如下：

xxxxxxxxxx
49
1
class goodgay
2
{
3
public:
4
    goodgay()
5
    {
6
        building = new Building;
7
    }
8
    void visit();               //成员函数写在类外
9
    
10
private:
11
    Building *building;
12
};
13

14
void goodgay::visit()
15
{
16
    cout << "好基友正在访问：" << building->m_sittingroom << endl;
17
    cout << "好基友正在访问：" << building->m_bedroom << endl;
18
}
19

20
class Building
21
{
22
    //告诉编译器 goodgay类是Building类的好朋友，可以访问到Building类中的私有内容
23
    friend class goodgay;
24
    
25
public:
26
    Building()
27
    {
28
        this->m_sittingroom = "客厅";
29
        this->m_bedroom = "卧室";
30
    }
31
public:
32
    string m_sittingroom;      //客厅
33
private:
34
    string m_bedroom;          //卧室
35
};
36

37
void test01()
38
{
39
    goodgay gg;
40
    gg.visit();
41
}
42

43
int main()
44
{
45
    test01();
46
    
47
    system("pause");
48
    return 0;
49
}

也可以将成员函数写在类外面，比如上面示例中 goodgay 类中的 visit() 成员函数。

4.4.3成员函数做友元

与全局函数、类做友元类似。核心代码如下：

xxxxxxxxxx
16
1
class Building
2
{
3
    //告诉编译器 goodgay类下的visit成员函数作为本类的好朋友，可以访问本类的私有属性
4
    friend void goodgay::visit();
5
    
6
public:
7
    Building()
8
    {
9
        this->m_sittingroom = "客厅";
10
        this->m_bedroom = "卧室";
11
    }
12
public:
13
    string m_sittingroom;      //客厅
14
private:
15
    string m_bedroom;          //卧室
16
};

4.5运算符重载

运算符重载的概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。

4.5.1加号运算符重载

作用：实现两个自定义数据类型的相加运算

示例1：成员函数实现 + 号运算符重载

xxxxxxxxxx
32
1
class Person 
2
{
3
public:
4
    Person(int a ,int b)
5
    {
6
        this->m_A = a;
7
        this->m_B = b;
8
    }
9
    
10
    //成员函数实现 + 号运算符重载
11
    Person operator+(Person &p)
12
    {
13
        Person temp;
14
        temp.m_A = this->m_A + p.m_A;
15
        temp.m_B = this->m_B + p.m_B;
16
        return temp;
17
    }
18
public:
19
    int m_A;
20
    int m_B;
21
};
22

23
void test01()
24
{
25
    Person p1(10,20);
26
    Person p2(30,40);
27
    
28
    Person p3 = p1 + p2;          //本质是Person p3 = p1.operator+(p2);
29
    cout << "p3.m_A = " << p3.m_A << endl;
30
    cout << "p3.m_B = " << p3.m_B << endl;
31
}
32

示例2：全局函数实现 + 号运算符重载

xxxxxxxxxx
33
1
class Person 
2
{
3
public:
4
    Person(int a ,int b)
5
    {
6
        this->m_A = a;
7
        this->m_B = b;
8
    }
9
    
10
public:
11
    int m_A;
12
    int m_B;
13
};
14

15
//全局函数实现 + 号运算符重载
16
Person operator+(Person &p1,Person &p2)
17
{
18
    Person temp;
19
    temp.m_A = p1.m_A + p2.m_A;
20
    temp.m_B = p1.m_B + p2.m_B;
21
    return temp;
22
}
23

24
void test02()
25
{
26
    Person p1(10,20);
27
    Person p2(30,40);
28
    
29
    Person p3 = p1 + p2;          //本质是Person p3 = operator+(p1,p2);
30
    cout << "p3.m_A = " << p3.m_A << endl;
31
    cout << "p3.m_B = " << p3.m_B << endl;
32
}
33