信息学竞赛 CPP 对象篇

面向对象概观

• 最早的面向对象语言 simula67
• 影响深远的 smalltalk(squeak/phora)，lisp
• 中规中矩的 Java / c#
• 灵活易用的 python / ruby
• 原型路线的 javascript / lua

面向过程、面向对象思路上的差异

面对一个问题时，

• 面向过程： 第一步做什么？然后再做什么?

• 面向对象：

  1. 应该有哪些实体一起来完成这个任务？
  2. 这些实体可以归为哪几个类型？
  3. 每个实体应该具有什么样的功能？
  4. 实体间该如何交换信息？

面向对象的思想是：模拟客观世界中的事物，来构造软件系统。

为什么要引入面向对象？

• 如何增强软件的重用性？
  • 基本的拷贝/粘贴？
  • 模式上的重复，提取为函数？
  • 例如，排序算法如何抽象出来，以供重用？
• 软件的可维护性
  • 可读性。 文档。实体间的联系。
  • 可修改性，可测试性
  • 可以只扩充，不修改吗？
• 用户的需求模糊，且不断变更，不断演化
  • 过程化的自顶向下很难应付
  • 对象模型是自底向上的思想

面向对象的特征

• 抽象
• 封装性。隐藏细节、结构、实现方式
• 继承。 c++支持多重继承
• 多态。 面向对象的精髓所在。

面向对象与基于对象

基于对象的语言，焦点在：使用对象。体现封装性。

有些无法派生出用户的“新类型”，当然就没法多态了。

有些不支持动态多态。当然，这样好处是：轻量级。注重效率，避免复杂化。

golang

面向对象关联

OOA，OOD，OOP

《UML》 统一建模语言，统一了Booch, OMT, OOSE 的表示方法，并扩展

工程标准，必学。

课程用到了：类图，对象图，活动图，时序图等。

类图示例

时序图示例

《设计模式》 23个经典模式及其衍生。对如何抽象和剥离有重要指导意义。

课程中会有部分涉及。

实时效果反馈

1. 关于面向对象编程语言，说法正确的是：__

• A C++是纯面向对象语言，不能面向过程编程。

• B c++是单继承模式，不能继承多个父类型。

• C c++使用基于原型（prototype）的对象模型

• D c++支持封装，继承，多态的面向对象特征

2. 相比于面向过程，使用对象的优势：__

• A 代码执行效率高，运行更快。

• B 更节省内存空间，适合于嵌入式环境

• C 大型工程项目更易于管理和维护，可重用性更好。

• D 很容易跨平台，可移植性更好。

答案

1=>D 2=>C

类与对象

类是图纸，是蓝图，对象是实体，是房屋。

类不在内存。对象在内存。

通过类可以创建对象。

通过1个类，可以创建多个对象。 1 : n

类的语法

class 类名 {
访问权限修饰符(private, public,protected):
    成员数据;
    成员函数;
};

class 是 struct 升级版

c++统一了class与struct，用struct定义类也可以，区别是：默认为public修饰符

成员变量，成员函数

也称为：

属性(property)，方法(method)

类的定义，体现了封装性。

类实现了：功能与实现的分离，实现了功能与数据结构的分离。

【示例】定时器

功能：

• 设置倒计时：分，秒
• tick() 走 1 秒
• 读取当前剩余：分，秒

// 定时器的定义
class Timer
{
public:
    void set(int min, int sec);
    void tick();
    int  get_min();
    int  get_sec();
private:
    int min;
    int sec;
};
////// 定时器的实现
void Timer::set(int m, int s)
{
    min = m;
    sec = s;
}
// 走1秒
void Timer::tick()
{
    if(sec>0){
        sec--;
    }
    else if(min>0){
        min--;
        sec = 59;
    }
    if(min==0 && sec==0)
        cout << "beep ... beep ... " << endl;
}
// 读取时间
int Timer::get_min() { return min; }
int Timer::get_sec() { return sec; }

使用方法：

Timer a;
a.set(1,15);
a.tick();
cout << a.get_min() << "," << a.get_sec() << endl;
for(int i=0; i<80; i++) a.tick();

当我们改变Timer实现机制时，只要功能不变，并不需要通知调用方。

// 定时器
class Timer
{
public:
    void set(int min, int sec);
    void tick();
    int  get_min();
    int  get_sec();
private:
    int sec;
};
/////// 实现
void Timer::set(int m, int s)
{
    sec = m * 60 + s;
}
// 走表
void Timer::tick()
{
    if(sec>0) sec--;
    if(sec==0)
        cout << "beep ... beep ... " << endl;
}
// 读数
int Timer::get_min() { return sec/60; }
int Timer::get_sec() { return sec%60; }

对象初始化

如果不对对象进行初始化，则成员变量值不确定

初始化途径：

• 定义成员变量时给初始值

• 创建对象时，用 { } 语法

• 构造函数（构造子）

实时效果反馈

1. struct 与 class 关键字的区别是：__

• A struct 默认成员为public, class默认为private

• B struct 中无法定义成员函数

• C struct 中无法定义private成员

• D struct 中无法初始化成员变量

2. 如果不对对象的成员数据进行初始化，其值为：__

• A 0

• B 系统默认值

• C 编译器指定值

• D 不确定

答案

1=>A 2=>D

对象与指针

对象是值语义

对象可以包含指针成员，它指向的东西不计入对象大小

指针可以指向对象，也可以当作对象数组来操作

对象内部的指针

• 指针指向的目标并不属于对象“领地”

class MyA
{
    int x;
    char* p;  // 指向的东西不在对象里
};

对象的复制会造成指针牵连现象

• 对象内部指针指向动态内存要小心（设计不好，就会泄漏）

==内存泄漏==过程示例

class MyA
{
public:
    void set(char* name, int age){
        x = age;
        p = new char [strlen(name)+1];
        strcpy(p,name);
    }
private:
    int x;
    char* p;
};

使用过程：

MyA a;
a.set("zhangsan", 10);
cout << sizeof(MyA) << endl;

修正：

class MyA
{
public:
    void set(char* name, int age){
        x = age;
        p = new char [strlen(name)+1];
        strcpy(p,name);
    }
    void finish(){
        delete [] p;
    }
private:
    int x;
    char* p;
};

指向对象的指针

通过指针来调用对象的成员函数，或访问成员变量

指针的运算是基于sizeof(对象)的

与一般指针无异，可以当作数组来使用

对象引用

在本质上，还是指针操作，形式上，可以当作别名。

实时效果反馈

1. 关于对象内部的指针成员，说法正确的是：__

• A 指针成员指向的数据也计算在sizeof(本对象)内

• B 指针成员指向动态内存时，当对象释放时，也会自动释放

• C 指针成员不能为NULL

• D 指针成员在对象复制时，只是复制指针本身，不包含其指向的东西

2. 关于对象引用，说法正确的是？：__

• A 对象引用可以理解为对象别名

• B 对象引用比对象指针操作速度更快

• C 通过对象引用无法修改对象的内容，只能读取

• D 对象引用本质是指针，其类型的 sizeof 为 4 字节。

答案

1=>D 2=>A

指针赋值与对象拷贝

指针赋值或者对象拷贝都可能引发指针牵连

这是复杂性的开端，

也是bug的发源地。

• 指针赋值

class MyA{
public:
    int x;
    int y;
    void show(){
        printf("(%d,%d)\n", x, y);
    }
};

其实，就是从前的 Point 定义（增加了show函数）

存在问题的使用方法：

MyA* p = new MyA{10,20};
MyA* q = p;  // 形式上的拷贝，不管内容的含义
q->x++;
p->show();  // ?? 可能觉得奇怪
delete p;
delete q;  // bug

更有甚者，可能会有另一个问题：

MyA* p = new MyA{10,20};
MyA* q = new MyA{30,40};
q = p;  // 苦乐不均啊！！
delete p;
delete q;

• 对象赋值（对象拷贝）

MyA* p = new MyA{10,20};
MyA q = *p;  // 这个是对象内存区的形式拷贝(memcpy)
p->x++;  // 不会产生牵连
q.show();
delete p;  // 与 q 无关

但是。。。。

如果对象中有指针项，问题就复杂了。

class LinkNode{
public:
    int data;
    LinkNode* next;
};

    LinkNode a{1,NULL};
    a.next = new LinkNode{2,NULL};
    LinkNode b = a;
    // 这次如何释放变成了难题。。。。

内存图景：

实时效果反馈

1. 当对对象指针进行赋值时，发生了什么？__

• A 两个指针的值不同，但指向对象内容相同

• B 两个指针值相同，指向同一个对象

• C 两个指针值相同，指向不同对象。

• D 两个指针值不同，指向不同对象。

2. 对象默认的拷贝行为，说法正确的是：__

• A 不能把堆空间的对象拷贝到栈空间

• B MyA b = a; 把 b 原来的内存信息抹掉了，换成了与 a 相同的信息

• C 当对象赋值 b=a; 时，如果b对象中有指针指向动态内存，则会自动回收。

• D 对象赋值比指针赋值速度快

答案

1=>B 2=>B

浅拷贝与深拷贝

如果不满意默认的拷贝行为，可以自己定义copy函数

对象对其动态内存的管理

例如，如何复制一个链表？

class LinkNode{
public:
    int data;
    LinkNode* next;
    void add(LinkNode* it){
        it->next = next;
        next = it;
    }
    void clear(){
        if(next==NULL) return;
        next->clear();
        delete next;
        next = NULL;
    }
    void show(){
        cout << data << " ";
        if(next) next->show();
    }
    LinkNode copy();  // 深度拷贝
};

猜测一下结果：

LinkNode a = {-1,NULL};
for(int i=9; i>=1; i--) a.add(new LinkNode{i,NULL});
//LinkNode b = a;
a.show(); cout << endl;
a.clear();
a.show(); cout << endl;

这样呢？

LinkNode a = {-1,NULL};
for(int i=9; i>=1; i--) a.add(new LinkNode{i,NULL});
LinkNode b = a;
b.show(); cout << endl;
a.clear();
b.show(); cout << endl;

默认行为：

我们来实现深度拷贝

拷贝会返回临时对象，不是对象指针。

class LinkNode{
public:
    int data;
    LinkNode* next;
    void add(LinkNode* it){
        it->next = next;
        next = it;
    }
    void clear(){
        if(next) next->clear();
        delete next;
        next = NULL;
    }
    void show(){
        cout << data << " ";
        if(next) next->show();
    }
    LinkNode copy();  // 深度拷贝
};
LinkNode LinkNode::copy()
{
    LinkNode t = {data, NULL};
    LinkNode* p = next;
    LinkNode* q = &t;
    while(p){
        q->next = new LinkNode{p->data, NULL};
        p = p->next;
        q = q->next;
    }
    return t;
}

实时效果反馈

1. 在定义copy成员函数时，如果返回局部变量对象的指针，会怎样?

• A 等到调用方拿到指针的时候，指针指向的对象已经是垃圾区了。

• B 可以安全操作，不要忘记了释放它指向的内存

• C 可以安全操作，不用释放内存，系统会自动释放

• D 产生编译错误

2. 在定义copy成员函数时，如果返回一个动态申请的对象的指针，会怎样？__

• A 调用方无法释放头节点的内存

• B 调用方如果采用对象赋值来接收拷贝结果，会使头节点内存泄漏

• C 调用方只要不忘记调用clear, 就不会内存泄漏

• D 会造成两个链表内存牵连而不独立。

答案

1=>A 2=>B

成员函数与this指针

疑惑

class Timer{
public:
    void set(int x);
    int get();
    void tick();
private:
    int sec;
};

问题：sec变量在哪里？

void Timer::set(int x)
{
    sec = x;  // sec从何而来？类里？
}
int Timer::get()
{
    return sec; // 与上一个sec是不是同一个变量？
}

问题：到底是一个sec，还是多个？存在哪里？什么时候出生的，什么时候释放？

    Timer a;
    a.set(10);
    Timer b;
    b.set(20);
    cout << a.get() << endl;

成员函数与普通函数的区别

成员函数是c++新创造的事物吗？

如果没有面向对象，c语言能实现这个功能吗？

我们可以！

多设计一个参数，就实现了一切！

struct T{
    int sec;
};
void set(T* that, int x)
{
    that->sec = x;
}
int get(T* that)
{
    return that->sec;
}

调用处：

T a;
set(&a, 10);
cout << get(&a) << endl;

this的身份

this 是编译器隐藏传入的一个指针

是常量，不能更改

无法重新赋值或进行指针运算

它表达的含义：当前正在哪个对象上工作

就是说：this 象征者当前对象。

==输出当前对象的地址来看一看==

有什么大用？我不知道有妨碍吗？

很多用处，但现阶段…..

• 当名字冲突时，可以明确指定

  void Timer::set(int sec)
  {
      //sec = sec;
      this->sec = sec;
  }

• 要求返回当前对象本身该怎么写呢？

  Timer* Timer::tick()
  {
      if(sec>0) sec--;
      return this;
  }

  还可以：

  Timer& Timer::tick()
  {
      if(sec>0) sec--;
      return *this;
  }

实时效果反馈

1. 关于 this 的说法，正确的是：__

• A this 是系统定义的静态变量，并且隐藏的。

• B this 可以被重新赋值

• C this 是系统隐含传入的一个形参变量

• D this 不可以作为返回值

2. this 的哪个用途不能用其它办法代替？ __

• A 形参名与成员数据名相同

• B 在成员函数中，调用当前对象的成员函数

• C 输出当前对象的内存地址

• D 返回当前对象的引用，以支持链式调用。

答案

1=>C 2=>D

构造子与析构子

对象出生时，内存是一片垃圾，这在有的场合无法忍受。

怎样==强制==用户必须初始化对象呢？

构造函数的目的

确保对象在任何场合被创建时，都是处于合理的状态（不是垃圾堆数据）

构造函数的语法：

1. 与类同名

2. 没有返回值（不是void）

3. 可以有多个（重载 overload）

   之所以称为：构造子，而不说构造函数，是因为它与一般函数不同，不能随意调用

   构造函数，析构函数是系统自动调用的，我们无法控制什么时候调用或不调用

当我们不定义构造函数时，系统提供一个无参默认构造，什么都不干。

当定义任意构造函数，表示用户自己接手，系统默认提供的收回。

class LinkNode{
public:
    LinkNode(int x){
        data = x;
        next = NULL;
    }
    int get(){ return data; }
private:
    int data;
    LinkNode* next;
};

这时，如果：

LinkNode a;  // 会报错，因为没有找到构造函数

可以补充一个无参构造：

    LinkNode(){
        data = 0;
        next = NULL;
        cout << "..LinkNode().." << endl;
    }

我们可以观察它什么时候被调用

    LinkNode a;
    a = LinkNode{};

对象创建的场合很多，经常是：防不胜防。

我们怎么知道对象有多少个？

析构函数追踪每个对象的消亡。

    ~LinkNode(){
        cout << "..LinkNode...die..." << endl;
    }

析构函数的目的

对象生前持有的==资源==在临终前，一定要归还，不管是何种原因死亡。

资源是广义，不一定是内存，还可能：文件句柄，画刷，socket等

其目的是：强制性 归还资源

比如，单链表，怎样保证它在销毁时不要忘记释放堆内存资源。

class LinkNode{
public:
    LinkNode(int x){
        data = x;
        next = NULL;
    }
    ~LinkNode(){
        cout << "destroy... " << endl;
        if(next) delete next;
        next = NULL;
    }
    LinkNode& add(int x){
        LinkNode* p = new LinkNode(x);
        p->next = next;
        next = p;
        return *p;
    }
    void show(){
        LinkNode* p = this;
        while(p){
            cout << p->data << " ";
            p = p->next;
        }
        cout << endl;
    }
private:
    int data;
    LinkNode* next;
};

使用方法：

    LinkNode head(-1);
    head.add(1).add(2).add(3);
    head.show();

实时效果反馈

1. 关于构造子的用法，说法正确的是：__

• A 用户必须在适当的时候调用构造子

• B 用户定义有参的构造子，系统提供无参的构造子

• C 构造子是系统自动调用的，用户无法调用

• D 有参的构造子必须调用无参的构造子

2. 关于析构函数，说法正确的是：__

• A 其作用是：把对象的状态恢复到默认值

• B 在对象销毁前，提供必要的收尾工作

• C 把对象中的所有指针置为NULL

• D 有多少个构造子，就对应多少析构子

答案

1=>C 2=>B

构造函数重载

析构函数只有一种形式，构造函数却经常花样百出。

构造函数经常有多个，为了不同的场合。

一般，无参构造一定要提供。

构造函数的花样

• 使用参数的默认值，来简化重载

• class Circle{
  public:
      Circle(){
          cout << "init Circle()" << endl;
      }
  //    Circle(int x, int y){
  //        cout << "init circle(int, int)" << endl;
  //    }
      Circle(int x, int y, int r=1){
          cout << "init circle(int, int, int)" << endl;
      }
  };

• 在一个构造函数中调用另一个构造函数

  Circle(int x, int y, int r=1){
  Circle();
  cout << "init circle(int, int, int)" << endl;
  }

• 抄袭已有对象创建新对象

  Circle(Circle* x){
      cout << "init circle(Circle*)" << endl;
  }

初始化列表

当一个对象中包含另一个对象时…..

包含指针不算，是包含完整的对象

观察初始化的顺序等行为：

// 平面直角坐标位置
class Point{
public:
    Point(){
        cout << "init point()" << endl;
        x = 0;
        y = 0;
    }
    Point(int x, int y){
        cout << "init point(x, y)" << endl;
        this->x = x;
        this->y = y;
    }
    void set(int x, int y){
        this->x = x;
        this->y = y;
    }
    int getx() { return x; }
    int gety() { return y; }
private:
    int x;
    int y;
};
// 平面上的圆形（圆心 + 半径）
class Circle{
public:
    Circle(){
        cout << "init circle()" << endl;
        pt.set(0,0);
        r = 1;
    }
    Circle(int r){
        cout << "init circle(int)" << endl;
        Circle();
        this->r = r;
    }
    void show(){
        printf("circle: (%d,%d)%d\n", pt.getx(),pt.gety(),r);
    }
private:
    Point pt;  // 圆心
    int r;  // 半径
};

比较如下创建对象：

//Circle a;   //此时，Point对象初始化几次？
Circle a(10);  // Point对象初始化时机和次数？
//a.show();

如何在外层对象初始化之前，对其包含对象初始化？？

比如，强制 圆心在 (1,1)

Circle():pt(1,1),r(10){
    cout << "init circle()" << endl;
    //pt.set(0,0);
    //r = 1;
}
Circle(int r):Circle(){  //基于另一构造函数，完成本构造
    cout << "init circle(int)" << endl;
    //Circle();  //这样不好，会引发内部对象多次初始化
    this->r = r;
}

非对象类型放在初始化列表里，没意义，但可以这么做。

实时效果反馈

1. 关于构造函数的说法，正确的是：__

• A 构造函数的返回值类型为： void，即，无返回值。

• B 构造函数可以重载，只要参数个数不等即可。

• C 构造中，可以调用另外一个版本的构造函数

• D 构造函数中，可以调用析构函数

2. 什么情况下，需要使用初始化列表：__

• A 可用可不用，与在构造函数中写没有太大区别

• B 当一个对象中含有其它对象时，需要在本对象初始化前为嵌入的对象初始化

• C 建议所有成员数据都用初始化列表，这样效率高

• D 当包含了另一个对象的指针或引用的时候

答案

1=>C 2=>B

对象的生存期

对象可以存在于栈，静态空间，或者堆内存中。

用于测试的类型 T，只有一个析构函数，必须是public

class T{
public:
    ~T(){
        cout << "destroy .. T .. " << endl;
    }
};

​ 其对象大小为1字节。

• 栈中的对象

  局部变量，在栈中分配，起始于左大括号，终于右大括号。

  对象被自动创建,自动释放,自动调用构造,自动调用析构。

• 立即数

  在表达式等语句中临时出现的对象。生存期只限于本语句。

  cout << "111" << endl;
  T{};
  cout << "222" << endl;

• for 全局

  for(T a;0;){
  }

• for 函数体

  for(int i=0; i<5; i++){
    T a;
  }

• 形式参数

  void f(T x){ }
  //。。。。调用：
      T a;
      f(a);

  如果，传入的是 T&，则本质上是传 T*, 这不会引发创建新对象

• 返回值

  T f(){
      T a;
      return a;
  }
  // 。。。。 调用：
      T x;
      x = f();

  这在不同的环境表现不同。

  有时，2个对象，有时 3 个对象。

  看看极端情况：

  T f(){}
  // 调用。。。。
    f(); f();

• 静态对象

  void f(){
      static T a;
  }
  // 调用。。。。。
     f(); f();

• 对象动态申请与释放

  new 类型 [ ]; 返回对象指针

  delete [ ] 指针; 释放对象内存

  当使用对象数组的时候，必须用 delete [] p; 的形式

  T* p = new T[5];
  delete [] p;

  如果忘记了 [ ]，则落入著名的大坑，造成内存泄漏

实时效果反馈

1. 当形参是对象引用类型时，说法正确的是：__

• A 调用函数会创建新的对象

• B 调用函数不会创建新对象，这点上，与对象指针类型的形参表现相同。

• C 调用时，会创建新对象，但函数结束不会自动调用析构函数

• D 不确定，与编译器的设置有关

2. 当动态分配对象数组时，对应的 delete 语句忘记了方括号，会怎样？__

• A 只释放了一个对象的内存，造成内存泄漏。

• B 内存可以释放，但只调用了一个析构函数。

• C 内存可以释放，但不会调用任何析构函数

• D 会引发语法错误

答案

1=>B 2=>B

对象的传递

【示例对象】 计数器对象

class Cnt{
public:
    Cnt(){ x = 0; }
    ~Cnt() { cout << "destroy .. counter ... " << x << endl; }
    void inc() { x++; }
    void dec() { x--; }
    int get() { return x; }
private:
    int x;
};
// 使用方法：。。。
    Cnt a;
    a.inc();
    a.inc();
    cout << a.get() << endl;

• 传递指针

  最常见的情况是，主调方持有对象，把指针传入函数，希望操纵它

  一般被调方没有管理其内存的责任。

  void f(Cnt* p){
      p->inc();
      p->inc();
  }

  通过这种方式，也可以间接返回多个值。比如，返回点的坐标：

  bool f(Point* p1, Point* p2){
      if(p1->x < 0 || p1->y <0) return false;
      *p2 = *p1;
      p2->x++; p2->y++; 
      return true;
  }

  逻辑上，p1 是输入参数，p2是输出参数

• 传拷贝

  传拷贝的应用场合是，不希望函数的操作影响主调方。

  void f(Cnt x)
  {
      for(;x.get(); x.dec()){
          cout << "f..work..." << endl;
      }
  }
  int main()
  {
      Cnt a;
      a.inc();
      a.inc();
      f(a);
      cout << a.get() << endl;
      return 0;
  }

• 传引用

  传引用，本质就是传指针，但可以使用对象而不是指针的而语法

  另外的好处是：

  引用不能运算，指针可以运算，

  void f(T& x){
      x++; // ????
      x[2] = ... //???
  }

总之，引用有了更多的限制，更安全。

顺便说：java中的指针，不叫指针，叫引用，道理即此。

• 返回指针

  1. 传入的指针，再传回去，耗费资源很少，带来方便。。。。

     比如，链式操作。

  2. 动态申请的对象，返回地址，需要调用方去释放资源。

  主调方一般通过对称的函数来完成释放。

  Cnt* make_cnt()
  {
      // 可能根据配置文件，完成对象的动态创建
      return new Cnt(); 
  }
  bool free_cnt(Cnt* p)
  {
      delete p;
  }

  典型错误：

  返回局地对象的指针，使用方拿到时，此对象已作废。

  T* f(){
      T a;
      return &a;  // 当对方收到这个指针时，a 已经死亡了。
  }

• 返回引用

  最常见的用法是：踢皮球

  传入的参数，再传回去，一般就是为了链式调用。

  Cnt& inc() { x++; return *this; }

  则，调用时：

  a.inc().inc().inc();

实时效果反馈

1. 下列说法正确的是：__

• A 形参为指针类型的目的是：修改主调方实参的指针值

• B 形参为指针，在调用时不会产生创建新对象的动作

• C 形参为对象引用，比形参为对象指针耗费更多的内存

• D 形参为指针时，如果在函数内被置为NULL，会清空主调方的对象。

2. 如果，在一个函数中，返回了本地对象的指针，将会导致__

• A 该对象无法被释放，导致内存泄漏

• B 本地对象可以被释放，但不会调析构函数

• C 主调方拿到指针时，本地对象已经销毁了，导致悬挂指针

• D 主调方拿到的指针为NULL

答案

1=>B 2=>C

静态成员函数

静态成员函数实际上接近于普通函数，只是拥有对对象的某些访问权限。

语法

函数用 static 修饰

调用时，不需要对象，直接 类名::静态成员函数

此时，类名的作用类似于：命名空间

逻辑上，静态成员函数，不封装到对象，但封装到类（外部可见性自己控制）

静态成员函数的常见使用场景

1. 运算是对称的，如果使用 对象.成员函数的方式，则体现不出对称性

   仔细体会下面两个add函数语义上的微妙差异

   class Cnt{
   public:
       Cnt(){
           x = 0;
       }
       Cnt& inc(){ x++; return *this; }
       Cnt& dec(){ x--; return *this; }
       void show() { cout << x << endl; }
       void add(Cnt& t){  // t 的值并入 我自己
           x += t.x;
       }
       static Cnt add(Cnt& a, Cnt& b){  // a,b都不变，返回新的
           Cnt t;
           t.x = a.x + b.x;
           return t;
       }
   private:
       int x;
   };

2. 第一个运算数不是对象，无法用 对象.成员函数的方式

   static Cnt add(int a, Cnt& b){
       Cnt a1;
       a1.x = a;
       return add(a1, b);
   }

3. 作为与本类型相关工具函数，并不需要对象

       static void help(){
           cout << "_____ Cnt help ____" << endl;
           cout << " Cnt a_name; " << endl;
           cout << " a_name.inc(); // add one " << endl;
           cout << " ....... " << endl;
       }

4. 其任务就是创建对象，现在流行称为：工厂方法

   当然在对象出生之前就可以调用。

   一般是根据配置文件，动态创建出对象，返回对象的指针。

       static Cnt* create(const char* txt){
           Cnt* p = new Cnt();
           sscanf(txt,"init=%d",&p->x);
           return p;
       }
   // 调用方：
       Cnt* p = Cnt::create("init=50");
       p->show();
       delete p;

静态成员函数的特征

没有自动传入的this指针

并不需要对象的存在，就可以被调用

实时效果反馈

1. 关于静态成员函数，说法==错误==的是：__

• A 静态成员函数无法通过对象来调用。

• B 静态成员函数的形参，并没有传入隐含的this指针

• C 静态成员函数，可以通过类名限定来调用

• D 静态成员函数，可以用来动态创建对象实例

2. 以下关于静态函数说法，==错误==的是__

• A 静态成员函数比普通成员函数少了this指针

• B 静态成员函数，可以在本类型的所有对象出生前调用

• C 静态成员函数，可以作为本类型的工具函数，并不依存于对象

• D 静态成员函数，可以用来释放对象申请的动态内存

答案

1=>A 2=>D

静态成员变量

静态成员变量是类级别的，不随着对象的出生而出生，所有对象出生前就存在了。

静态成员变量语法

定义时，加 static 修饰符

例如： static int x;

必须在外部进行初始化

例如： int T::x = 100;

这里，充分体现了类是蓝图，它不会耗费内存。

静态成员变量特性

1. 对象未创建，就已经存在，可以用静态方法操纵它

2. 与全局变量，静态变量类似，存在静态空间

3. 只有一份，不跟随对象创建，不属于sizeof(对象) 大小

4. 它可以被本类型所有对象共享。

   class T{
   public:
       int a;  //跟随对象而生灭
       static int A;  //只有一份，需要在外部创建并初始化
   };

   当，如下创建，内存图景：

       T a;
       T* p = new T(); 
    delete p; // 不要用free，那样不会调用析构

静态成员变量的典型用途

1. 用于本类型对象的管理

   例如：检测内存泄漏。用一个 int 记录本类型对象现存的个数。

   class T{
   public:
       T(){ A++; }
       ~T(){ A--; }
       int x;
       static int A;
   };

2. 设计模式中，著名的：单例模式

   有的时候，我们希望只有唯一的对象（比如，连接sqlite数据库的连接对象）

   这可以通过把构造函数私有化来实现。

   提供 static 函数来获得这个唯一对象。

   class T{
   public:
       static T* get_instance(){
           if(pObj==NULL) pObj = new T();
           return pObj;
       }
       static void free(){
           if(pObj){
               delete pObj;
               pObj = NULL;
           }
       }
   private:
       T(){}
       ~T(){}
       static T* pObj;
   };
   T* T::pObj = NULL; // 不要忘记真正创建变量
   int main()
   {
       T* p1 = T::get_instance();
       T* p2 = T::get_instance();
       cout << (p1 == p2) << endl;
       return 0;
   }

实时效果反馈

1. 关于静态成员变量，说法正确的是：__

• A 静态成员变量可以在类内直接赋给初始值

• B 静态成员变量必须在类外再次声明，以分配存储空间。

• C 静态成员变量必须在静态成员函数中才能访问

• D 静态成员变量在所有该类对象都析构后，自动释放内存。

2. 单例模式的作用是：__

• A 确保所有使用者，使用的均是同一个对象。

• B 保证对象在程序启动时，就已经创建好。

• C 可以更快速地创建对象

• D 可以让多个对象，通过同一个指针被外界使用。

答案

1=>B 2=>A

对象的状态

对象是持有状态的实体

纯函数是：输入到输出的映射关系。普通函数=纯函数 + 副作用。

同一个类，创建的多个对象可以处于不同的状态。

成员函数的执行，与其关联的对象有关，即，该函数执行的上下文(contex)

饮料机a.购买(可乐，1)

饮料机b.购买(可乐, 1)

对象的状态迁移

外界对对象发出指令（向对象发送消息）

对象响应消息，改变自身的状态（这是与普通函数式思维的不同）

【实例】小机器人对象

我们先设计一下，小机器人有哪里能力。

然后写出它的使用方式【测试驱动法TDD】

    Robot a;
    a.go(5);
    a.right();
    a.go(10);
    a.left().left().go(20);  //需要支持链式
    a.show();
    a.reset();
    a.show();

最后，实现小机器人类：

enum DIR{
    NORTH, EAST, SOUTH, WEST
};
struct Point{
    int x;
    int y;
    Point(){
        x = 0;
        y = 0;
    }
    void show(){
        printf("(%d,%d)", x, y);
    }
};
class Robot{
public:
    Robot(){
        dir = NORTH;
    }
    Robot& go(int step){
        switch (dir) {
        case NORTH:
            pt.y += step;
            break;
        case EAST:
            pt.x += step;
            break;
        case SOUTH:
            pt.y -= step;
            break;
        case WEST:
            pt.x -= step;
            break;
        }
        return *this;
    }
    Robot& left(){ dir = (DIR)((dir-1+4)%4); return *this; }
    Robot& right(){ dir = (DIR)((dir+1)%4); return *this; }
    void show() {
        pt.show(); cout << " ";
        switch (dir) {
        case NORTH:
            cout << "north";
            break;
        case EAST:
            cout << "east";
            break;
        case SOUTH:
            cout << "south";
            break;
        case WEST:
            cout << "west";
        }
        cout << endl;
    }
    void reset(){
        pt.x = 0; pt.y = 0;
        dir = NORTH;
    }
private:
    Point pt;  //当前坐标
    DIR dir;  // 朝向
};

封装的含义

• 封装是隔离

  隔离了功能和实现，隔离了外部特征和内部实现机制

• 封装是关联

  关联了成员函数和对象状态，通过函数改变状态，函数服务于状态，不能独立存在

• 封装是隐藏

  隐藏了数据，隐藏了结构，隐藏了实现细节

拓展：

只有一个小机器人对象，是寂寞的世界

如果，有多个小机器人

go 需要考虑碰撞的问题

可以相互协作完成任务

。。。。

让小机器人走迷宫，到岔路口，像孙悟空一样，复制出多个小机器人，走不同的路

两个撞了，就自动销毁一个。。。。。

实时效果反馈

1. 关于对象的封装性，说法正确的是：__

• A 封装就是把对象加锁，避免同时访问

• B 封装就是把对象保护起来，避免与外界交互

• C 封装一般是把成员函数隐藏，把数据暴露出来

• D 封装就是把结构和实现隐藏，把功能暴露出来

2. TDD在面向对象中的大体做法是：__

• A 自顶向下的设计

• B 螺旋上升的开发模型

• C 先写对象如何使用，然后在需求的推动下，完善类的功能

• D 先写出对象的数据，围绕着数据写它的功能

答案

1=>D 2=>C

对象的状态（2）

接上节，小机器人类实现细节的补充：

1. TDD开发风格，先写如何用，再写如何实现

   让==需求推动==着我们去实现功能

   降低程序员的心智负担，只关注当前的问题

2. TDD提倡==渐进式==的风格，不要一次写很多，改一点，测试一点

   通过不断反馈，不断完善，来接近最终目标

3. 当条件允许时，优先采用可读性好的写法，易于维护

   程序的生命力在于它的可维护性，而不是正确性

4. 注意枚举类型与整型的关系

   自动转换关系

5. 重用性很重要，提供何种功能，有利于重用？有利于组合？

   功能单一性——高内聚

   联系简化 —— 低耦合

6. 在面向对象的设计中，一般优先使用==组合模式==，其次才是继承模式

   组合，就是在对象数据中包含其它的对象（或指针，也有把这个称为==聚合==的）

实时效果反馈

1. 关于c++枚举类型与整型关系，说法正确的是：__

• A 整型和枚举类型间可以自动相互转化

• B 枚举类型可自动转整型，整型不能自动转枚举

• C 整型可自动转枚举，枚举不能自动转整型

• D 两者类型不同，不可自动转化

2. 为了提高软件单元的复用性，设计时，我们应该遵循__原则

• A 高内聚，高耦合

• B 高内聚，低耦合

• C 低内聚，高耦合

• D 低内聚，低耦合

答案

1=>B 2=>B

对象内存结构

当没有继承，没有虚函数的时候，c++的对象内存模型相当简单

1. 空对象，占用 1 字节

2. 普通成员数据，跟随对象存储，属于sizeof(对象)，可能涉及字对齐

3. 静态成员数据，全局存储，静态空间，程序启动后确定下来

4. 普通成员函数，静态成员函数，存储在代码区，不跟随对象

   逻辑上： 对象 = 数据 + 方法

   存储上： 对象 = 数据

   成员函数是障眼法，被翻译为普通函数，多一个隐含的参数 this 指针

   静态成员函数，没有this，因而等价于普通函数，只是编译器控制了访问权限

   不管对象创建多少，函数都只有一份拷贝

1. 不管是： 对象.f() 指针->f() 还是 引用.f()，本质上都一样，

   调用f，传入一个指针，名字为 this，装着对象内存首地址

2. 当对象的数据中含有其它对象时，累计其size；当含有任何类型指针，增加4字节

3. 当对象的数据中，含有数组，则累计数组size，若含有数组地址，则只增4字节

   当有指针指向动态内存，只增4字节

   但，注意，一般在析构中要释放动态申请的内存。

示例

【Stu对象】包含：学号，姓名，分数。要求姓名采用动态存储法

class Stu{
public:
    Stu(int id, char* name){
        this->id = id;
        this->name = new char [strlen(name)+1];
        strcpy(this->name, name);
        score = 0;
    }
    ~Stu(){
        delete [] name;
    }
    void inc(int x=1){ score += x; }
    void dec(int x) { score -= x; }
    void show(){
        cout << id << ": " << name << "," << score << endl;
    }
private:
    int id;
    char* name;
    int score;
};

管理对象数组

对象数组是，包含对象本身的数组。其元素是对象。

如果需要创建对象数组，对象必须支持无参构造的方式。

如果不能接受对象的随机值，希望表达“无意义”这个概念。可以选用特殊值。

如果希望==批量初始化==对象，一般要需要一个 init 函数

通常，批量初始化的数据有某种连续特征，可以通过运算动态获得。

如果在栈中开数组，

会自动调用析构函数。

在堆中，则需要 delete [ ] p 来触发

管理对象指针数组

对象指针数组包含的是对象的指针，数组的元素是指针

也就是说，释放数组，并不会自动释放对象。

当管理对象时，我们需要考虑==两个==问题：

1. 对象的内存释放了吗？
2. 对象的析构函数调用了吗?

这是两个独立的问题，要小心！！！

实时效果反馈

1. 关于对象的存储，说法正确的是：__

• A 对象的数据和操纵它的成员函数存在一起。

• B 对象的内存包含了它的非静态数据和this指针。

• C 当无继承时，对象的内存包含了它的所有非静态数据。

• D 对象的内存总是动态分配的，其大小等于所有public数据大小之和

2. 关于对象指针数组，说法正确的是：__

• A 在栈中分配的数组释放时，会自动调用每个指针的析构函数

• B 在栈中分配数组，每个元素必须是同一类型对象的指针

• C 本质就是指针数组，指针指向的内容由用户自行管理

• D 数组可以自动分配，但，删除时需要调用 delete [ ] p;

答案

1=>C 2=>C

对象内存结构（2）

接上节，对象及其动态内存的使用，有许多==著名大坑==，

作为成熟的程序员，每个都应该踩过。

1. 养成好习惯，delete 前判断NULL，删除后置为NULL
2. 指向动态内存的指针被重新赋值，赋值前，问自己：释放了不？
3. 只要不是构造函数，都可能被调用多次，一定要考虑好多次调用的后果。
4. free 不是 delete，它会释放内存，但不调用析构
5. delete 不是 delete [ ]， 它会释放内存，会调用析构，但只调用 1 个。
6. 养成好习惯，自己 new … ， 一定检查是否有对一个的 delete
7. 避免动态内存的最好方法之一：尽量不用它（用数组代替指针）

class Stu{
public:
    Stu(){
        id=-1;
        name[0] = '\0';
        score=-999;
    }
    Stu(int id, char* name):Stu(){
        init(id, name, 0);
    }
    ~Stu(){
        cout << "destroy...stu.." << id << endl;
    }
    void init(int id, char* name, int score){
        this->id = id;
        strncpy(this->name, name, 25);
        this->score = score;
    }
    void inc(int x=1){ score += x; }
    void dec(int x) { score -= x; }
    void show(){
        cout << id << ": " << name << "," << score << endl;
    }
private:
    int id;
    char name[30];
    int score;
};

实时效果反馈

1. 对成员函数的指针数据重新赋值, 可能引起什么不良后果：__

• A 悬挂指针

• B 内存泄漏

• C 忘记调析构函数

• D 触发垃圾回收

2. 成员指针 delete 后，不置为NULL，有什么隐患？__

• A 悬挂指针

• B 内存泄漏

• C 栈溢出

• D 数组访问越界

答案

1=>B 2=>A

拷贝构造

拷贝构造就是对象克隆

一个对象，可能有各种各样的出生方式。

1. 指定合适的参数出生（最容易识别）

2. 无参默认出生

   有时，是隐式的：

   比如，对象数组

   比如，在一个对象中包含了另一个对象

3. 拷贝另一个对象而出生

   有时，很隐蔽。

   比如：对象实参传递给形参；函数返回一个对象

4. 由赋值语句而出生

   把一个对象赋值给另一个对象

我们来监测对象的出生和销毁

class A{
public:
    A(){  cout << "default create" << endl; }
    A(A& x){ cout << "copy create" << endl; }
    ~A(){ cout << "destroy " << endl; }
};

注意：

拷贝构造的形参，一定是引用类型，否则本身就会引发拷贝构造。

在其它场景，同样使用引用可以避免拷贝的发生

A a;
A b = a;  // 拷贝构造
A c(a);   // 拷贝构造
b = c;  // 这是对象赋值，并没有新的对象出生，因而无所谓：“构造”

函数中传递的情况：

A f(A x){ return x; }
// ..... 调用处：
    A a;
    f(a);

如果不定义拷贝构造

系统执行默认的拷贝行为，可能不是我们期望的。

可以理解为：内存级别的“照相”复制

即是： memcpy(&b, &a, sizeof(a));

这对简单对象，完全正确，比如： Point， Cnt 等

如果对象内有指针就要当心了，会造成：指针牵连

浅拷贝与深拷贝

系统默认的拷贝构造行为是：浅拷贝。

如果需要深拷贝，则自己定制。

我们前面讲过：浅拷贝，深拷贝的话题。其内容与对象拷贝完全类似。

甚至，如果我们已经写好了 copy 函数，可以在拷贝构造中，直接调用它。

下面给出链表对象的拷贝构造例子：

队列对象

struct Node{
    int data;
    Node* next;
    Node(int x){
        data = x;
        next = NULL;
    }
};
class Que{
public:
    Que() { head=NULL; tail=NULL; }
    ~Que() { int x;  while(pop(x)); }
    Que& push(int x){
        Node* t = new Node(x);
        if(tail){
            tail->next = t;
            tail = t;
        }else{
            tail = t;
            head = t;
        }
        return *this;
    }
    bool pop(int& x){
        if(head==NULL) return false;
        Node* t = head;
        if(head==tail){
            head = NULL;
            tail = NULL;
        }else{
            head = t->next;
        }
        x = t->data;
        delete t;
        return true;
    }
private:
    Node* head;
    Node* tail;
};

基本用法：

    Que a;
    a.push(10).push(20).push(30);
    int x;
    while(a.pop(x)) cout << x << endl;

但，有个致命隐患，当拷贝队列对象的时候。。。。。

定义拷贝构造来复制整个队列：

实现起来也不难，关键是充分利用已经有的基础设施

    Que(Que& t):Que(){
        Node* p = t.head;
        while(p){
            push(p->data);
            p=p->next;
        }
    }

实时效果反馈

1. 如果A是类，执行 A a; A b; b=a; 说法正确的是：__

• A 调用 2 次默认构造，1 次拷贝构造

• B 调用 2 次默认构造

• C 调用 1 次默认构造，1 次拷贝构造

• D 与编译环境有关

2. 下列哪种行为肯定==不会==引发拷贝构造__

• A 调用形参为对象的函数

• B 用一个对象来初始化另一个局地对象

• C 从函数返回一个对象类型

• D 从函数返回一个对象引用类型

答案

1=>B 2=>D

赋值函数

前边的课程中，我们知道：

运算符的本质就是函数，参数就是运算数

= 是运算符，b = a 的默认动作是：把 a 的值拷贝给 b，同时返回 b 的值

当，a b 都是对象时，复杂了。。。。

默认的赋值行为

b = a; 把 a 对象的内存“照相”拷贝到 b，返回b对象的引用。

当简单对象时，这种行为是正确的。

当对象复杂时，比如，含有指针，产生牵连（与拷贝构造类似)

除此之外，还有更严重的错误：

上一节的 Que 类

// 链表的节点
struct Node{
    int data;
    Node* next;
    Node(int x){
        data = x;
        next = NULL;
    }
};
//先进先出的队列
class Que{
public:
    Que() { head=NULL; tail=NULL; }
    Que(Que& t):Que(){      //保证在拷贝构造前，head,tail为NULL 
        Node* p = t.head;
        while(p){
            push(p->data);
            p=p->next;
        }
    }
    ~Que() { int x;  while(pop(x)); }
    Que& push(int x){  //返回Que& 为了链式操作
        Node* t = new Node(x);
        if(tail){
            tail->next = t;
            tail = t;
        }else{
            tail = t;
            head = t;
        }
        return *this;
    }
    bool pop(int& x){  //不设计为直接返回 int，因为有队列空的情况 
        if(head==NULL) return false;
        Node* t = head;
        if(head==tail){
            head = NULL;
            tail = NULL;
        }else{
            head = t->next;
        }
        x = t->data;
        delete t;
        return true;
    }
private:
    Node* head; //指向对头，从这里弹出数据
    Node* tail; //指向队尾，在其后压入数据
};

赋值函数语法

    ~Que() { clear(); }
    void clear(){ int x;  while(pop(x)); }
    Que& operator=(Que& t){
        clear();
        Node* p = t.head;
        while(p){
            push(p->data);
            p=p->next;
        }
        return *this;
    }

实时效果反馈

1. operator= 运算符重载，为什么要返回引用类型__

• A 为了支持连续赋值，形如： c = b = a;

• B 语法规定，否则编译不过

• C 为了和形参一致

• D 为了兼容 c 语言

2. 与默认的拷贝构造行为相比，默认的对象赋值行为，可能增加的危害是：__

• A 对象牵连

• B 悬挂指针

• C 内存泄漏

• D 栈溢出

答案

1=>A 2=>C

友元函数

一个规范的类，

应该至少满足：封装性，即是，它把内部的数据和实现机制隐藏起来。

但，有的时候不方便，

比如，这个类可能需要向调试、测试、诊断等工具放开权限。

类比现实世界，

每个人都有隐私，但，我们不应该对医生或牧师隐瞒。

c++，为了高效率解决这个冲突，引入了友元函数

什么是友元函数？

一句话来概括：友元函数就是一个对某个类有特权的普通函数。

谁来授权？

类对该函数授权，加 friend 修饰符。

要点：

1. 友元函数只是外部的普通函数，并非本类成员函数，因而：
2. 它没有隐藏的 this 指针。
3. 如果需要它操纵对象（读取或改写），必须显式地传入对象。
4. 它不需要this，当然，可以使用类的静态成员函数或静态成员数据。

真实的例子（月结打卡类Punch）

class Punch{
public:
    Punch(){ data = 0; }
    void set(int day){
        if(day<1 || day>31) return;
        data |= 1 << (day-1);
    }
    bool get(int day){
        if(day<1 || day>31) return false;
        return  data & (1 << (day-1));
    }
private:
    unsigned int data; // 按二进制位记录每天打卡情况
};