C++面向对象程序设计-北京大学-郭炜【课程笔记（四）】

C++面向对象程序设计-北京大学-郭炜【课程笔记（四）】

• 1、this指针
• • 1.1、this指针的作用
  • 1.2、this指针和静态成员函数
• 2、静态成员变量和静态成员函数
• • 2.1、基本概念
  • 2.2、基本概念总结
  • 2.3、如何访问静态成员
  • 2.4、静态成员变量的使用场景（重要）
  • 2.5、2.4节中CRectangle类写法，有何缺陷？
• 3、成员对象和封闭类
• • 3.1、封闭类构造函数的初始化列表
  • 3.2、封闭类构造函数和析构函数调用顺序
  • 3.3、封闭类的复制构造函数（难理解）

开始课程：P11 1_1. this指针

课程链接：程序设计与算法（三）C++面向对象程序设计 北京大学 郭炜

课程PPT：github提供的对应课程PPT

1、this指针

C++是没有自身编译器的，需要使用C语言的编译器，所以C++在编译时需要把语言转换为对应的C语言。

实例1：C++程序到C程序的翻译:（下图好理解，不做解释）

1.1、this指针的作用

this指针的作用 ：指向成员函数所作用的对象。

非静态成员函数中可以直接使用this来代表指向该函数

作用的对象的指针。

实例2:

#include<iostream>

class Complex
{
    public:
        double real, imag;
        void Print()
        {
            std::cout << real << "," << imag;
        }
        Complex(double r, double i): real(r), imag(i)
        {     }
        Complex AddOne()
        {
            this -> real++;   // 等价于 real++
            this -> Print();  // 等价于 Print()
            return * this;    // 返回this指：代表返回修改对象的自身
        }
};

int main ()
{
    Complex c1(1, 1), c2(0, 0);
    c2 = c1.AddOne();   // 这里就用到了return * this;
    return 0;
}
// OUT
2,1

实例3:

实例4:

1.2、this指针和静态成员函数

静态成员函数中不能使用 this 指针！因为静态成员函数并不具体作用与某个对象! 因此，静态成员函数的真实的参数的个数，就是程序中写出的参数个数！

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

2.1、基本概念

静态成员：在说明前面加了static关键字的成员。
定义：普通成员变量每个对象有各自的一份，而静态成员变 量一共就一份，为所有对象共享。

• 普通成员要量、函数：对于無一TCRectangle对象来说都是单独一份的，每个对象之间相互不干扰。
• 静态成员变量或函数：对于每一个CRectangle对象之间是共享的，更改其中一个CRectangle对象的静态成员变量或函数，其他CRectangle对象的静态成员变量和函数也随之改变。

• 普通成员变量每个对象有各自的一份，而静态成员变量一共就一份，为所有对象共享。

2.2、基本概念总结

• 普通成员变量每个对象有各自的一份，而静态成员变量一共就一份，为所有对象共享。
• 普通成员函数必须具体作用于某个对象，而静态成员函数并不具体作用与某个对象。
• 因此静态成员不需要通过对象就能访问。
• 静态成员变量本质上是全局变量，哪怕一个对象都不存在，类的静态成员变量也存在。
• 静态成员函数本质上是全局函数。
• 设置静态成员这种机制的目的是将和某些类紧密相关的全局变
  量和函数写到类里面，看上去像一个整体，易于维护和理解。

2.3、如何访问静态成员

1、类名::成员名

Cectangle::PrintTotal();

2、对象.成员名

Cectangle r;
r.PrintToTal();

3、指针->成员名

Cectangle * p = & r;
p -> PrintTotal();

4、引用.成员名

Cectangle & ref = r;

int n = ref.nTotalNumber;

2.4、静态成员变量的使用场景（重要）

静态成员变量的作用：考虑一个需要随时知道矩形总数和总面积的图形处理程序，可以用全局变量来记录总数和总面积，用静态成员将这两个变量封装进类中，就更容易理解和维护

注意事项1： 必须在定义类的文件中对静态成员变量进行一次声明，声明的同时可以初始化，也可以不出初始化。

实例:

#include<iostream>

class CRectangle
{
    private:
        int w, h;
        static int nTotalArea;
        static int nTotalNumber;
    public:
        CRectangle(int w_,int h_);
        ~CRectangle();
        static void PrintTotal(); 
};

CRectangle::CRectangle(int w_, int h_)
{
    w = w_;
    h = h_;
    nTotalNumber ++;
    nTotalArea += w * h;
}

CRectangle::~CRectangle()
{
    nTotalNumber --;
    nTotalArea -= w * h;
}

void CRectangle::PrintTotal()
{
    std::cout << "nTotalNumber = " << nTotalNumber << ";" << "nTotalArea = " << nTotalArea << std::endl;
}

// 注意事项：必须在定义类的文件中对静态成员变量进行一次声明
// 或初始化。否则编译能通过，链接不能通过。
int CRectangle::nTotalNumber = 0;   // 声明的同时可以初始化，也可以不出初始化
int CRectangle::nTotalArea = 0;

int main()
{
    CRectangle r1(3,3), r2(2,2);
    //cout << CRectangle::nTotalNumber; // Wrong , 私有
    CRectangle::PrintTotal();   // 输出：nTotalNumber = 2;nTotalArea = 13
    r1.PrintTotal();            // 输出：nTotalNumber = 2;nTotalArea = 13
    r2.PrintTotal();            // 输出：nTotalNumber = 2;nTotalArea = 13
    return 0;
}

// OUT
nTotalNumber = 2;nTotalArea = 13
nTotalNumber = 2;nTotalArea = 13
nTotalNumber = 2;nTotalArea = 13

注意事项2： 在静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数。

2.5、2.4节中CRectangle类写法，有何缺陷？

解决办法：为CRectangle类写一个复制构造函数

3、成员对象和封闭类

封闭类: 一个类的成员变量是另一个类的对象包含，此成员对象的类叫封闭类 (Enclosing)

#include<iostream>
class CTyre 
{ 
    //轮胎类
    private:
        int radius; //半径 
        int width; //宽度
    public:
        CTyre(int r, int w):radius(r), width(w) { }
};
class CEngine   // 这个类什么都没写，有无参构造函数
{ 
    //引擎类
};

class CCar 
{ 
    //汽车类 "封闭类"
    private:
        int price; //价格
        CTyre tyre;
        CEngine engine;   // 不用初始化，有无参构造函数
    public:
        CCar(int p, int tr, int tw);  // 构造函数的声明
};
CCar::CCar(int p, int tr, int w)  // 构造函数的定义
:price(p), tyre(tr, w)   // 构造函数的初始化：初始化列表
{
};
int main()
{
    CCar car(20000,17,225); 
    return 0;
}

3.1、封闭类构造函数的初始化列表

1、定义封闭类的构造函数时，添加初始化列表；

类名::构造函数(参数表):成员变量1(参数表),成员变量2(参数表), ...

{

...

}
2、成员对象初始化列表中的参数

• 任意复杂表达式
• 函数 / 变量 / 表达式中的函数，变量有定义

3.2、封闭类构造函数和析构函数调用顺序

实例：

#include<iostream>
using namespace std;

class CTyre {
    public:
        CTyre() { cout << "CTyre contructor" << endl; }
        ~CTyre() { cout << "CTyre destructor" << endl; }
};
class CEngine {
    public:
        CEngine() { cout << "CEngine contructor" << endl; }
        ~CEngine() { cout << "CEngine destructor" << endl; }
};
 
class CCar {
    private:
        CEngine engine;
        CTyre tyre;
    public:
        CCar( ) { cout << "CCar contructor" << endl; }
        ~CCar() { cout << "CCar destructor" << endl; }
};

int main()
{
    CCar car; 
    return 0;
}

// OUT
CEngine contructor
CTyre contructor
CCar contructor
CCar destructor
CTyre destructor
CEngine destructor

3.3、封闭类的复制构造函数（难理解）

#include<iostream>

class A
{
    public:
        A() 
        { 
            std::cout << "default" << std::endl;
        }
        A(A & a)
        {
            {std::cout << "copy" << std::endl;}
        }
};
 
// 封闭类
class B 
{
    A a;
};

int main()
{
    B b1, b2(b1);  // b1调用了B类的自动生成的无参构造函数，b2调用了B类的自动生成的复制构造函数
    return 0;
}
// OUT
default
Copy

输出：default、Copy

说明b2.a是用类A的复制构造函数初始化的。而且调用复制构造函数时的实参就是b1.a。