类和对象（Week 3）

内联成员函数和重载成员函数

内联成员函数

• inline + 成员函数
• 整个函数题出现在类定义内部

class B{
  inline void func1(); //方式1
  void func2() //方式2
  {
    
  };
};

void B::func1(){}

成员函数的重载及参数缺省

• 重载成员函数
• 成员函数——带缺省参数

#include<iostream>
using namespace std;
class Location{
  private:
  	intx,y;
  public:
  	void init(int x=0,int y=0); //存在2个缺省参数
  	void valueX(int val) {x = val;}//1
  	int valueX(){return x;}//2
  //1和2是重载函数
}

• 使用缺省参数要注意避免有函数重载时的二义性

构造函数

基本概念

• 成员函数的一种
  • 名字与类名相同，可以有参数，不能有返回值（void也不行）
  • 作用时对对象进行初始化，如给成员变量赋初值
  • 如果定义类的时候没写构造函数，则编译器生成一个默认的无参数的构造函数
    • 默认构造函数无参数，无任何操作
  • 如果定义了构造函数，则编译器不生成磨人的无参数的构造函数
  • 对象生成时构造函数自动被调用。对象一旦生成，就再也不能在其上执行构造函数
  • 一个类可以有多个构造函数
• 为什么需要构造函数
  1. 执行必要初始化工作，不需要专门再写初始化函数
  2. 有时对象没被初始化就使用，会导致程序出错

class Complex{
  private:
  	double real,imgae;
  public:
  	void Set(double r, double i);
};//编译器自动生成默认的构造函数

Complex c1;//默认的构造函数被调用
Complex* pc = new Complex;//默认的构造函数被调用

class Complex{
  private:
  	double real,imgae;
  public:
  	Complex(double r, double i = 0);
};
Complex::Complex(double r, double i){
  real = r;
  imag = i;
}

Complex c1; //error,缺少构造函数的参数
Complex *pc = new Complex;//error,没有参数
Complex c1(2); //OK
Complex c1(2,4),c2(3,5);
Complex *pc = new Complex(3,4);

• 可以有多个构造函数，参数个数或类型不同

class Complex{
  private:
  	double real,imgae;
  public:
  	void Set(double r, double i);
  	Complex(double r,double i);
  	Complex(double r);
  	Complex(Complex c1,Complexc2);
};

Complex::Complex(double r, double i)
{
  real = r;imag = i;
}

Complex::Complex(double r)
{
  real = r; imag = 0;
}
Complex::Complex(Complex c1, Complex c2)
{
  real = c1.real+c2.real;
  imag = c1.imag+c2.imag;
}
Complex c1(3),c2(1,0),c3(c1,c2);
//c1={3,0} c2={1,0} c3={4,0};

构造函数在数组中的使用

class CSample{
  	int x;
  public:
  	CSample(){
      cout<<"Constructor 1 Called"<<endl;
    }
  	CSample(int n){
      x = n;
      cout<<"Constructor 2 Called"<<endl;
    }
};

int main()
{
  CSample array1[2]; // 1 1
  cout<<"step1"<<endl;
  CSample array2[2] = {4,5};//2 2
  cout<<"step2"<<endl;
  CSample array3[2] = {3};//2 1
  cout<<"step3"<<endl;
  CSample *array4 = new CSample[2];//1 1
  delete []array4; // 收回空间
  return 0;
}

class Test{
  public:
  	Test(int n){ }//(1)
  	Test(int n, int m){ }//(2)
  	Test(){ }//(3)
};
Test array1[3] = {1,Test(1,2)} //三个元素分别用(1),(2),(3)进行初始化
Test array2[3] = {Test(2,3),Test(1,2),1};//2 2 1
Test * pArray[3] = {new Test(4), new Test(1,2)};//1 2 ❌

复制构造函数（copy constructor）

• 基本概念
  • 只有一个参数，即对同类对象的引用
  • 形如 X::X( X&)或X::X(const X &)，二选一，后者能以常量对象作为参数
  • 如果没有定义复制构造函数，那么编译器生成默认复制构造函数，默认的复制构造函数完成复制功能
  • 如果定义了复制构造函数，默认的复制构造函数将不存在。

class Complex{
  private:
  	double real,imag;
};
Complex c1;//调用缺省无参构造函数
Complex c2(c1);//调用缺省的复制构造函数，将c2初始化成和c1一样

class Complex{
  public:
  	double real,imag;
  Complex(){ }
  Complex(const Complex & c){
    real = c.real;
    imag = c.imag;
    cout<<"Copy Constructor called";
  }
};
Complex c1;
Complex c2(c1);

• 注意
  • 不允许有形如X::X(X)的构造函数

class CSample{
  CSample(CSample c){
    //error,不允许这样的构造函数
  }
}

• 复制构造函数起作用的三种情况

  1. 当用一个对象去初始化同类的另一个对象时

     Complex c2(c1);
     
     Complex c2 = c1; //初始化语句，非赋值语句
     

  2. 如果某函数有一个参数是类A的对象，那么该函数被调用时，类A的复制构造函数将被调用

     class A
     {
       public:
       A(){ };
       A(A & a){
         cout<<"Copy constructor called"<<endl;
       }
     }
     
     void Func(A a1){ }
     int main(){
       A a2;
       Func(a2);
       return 0;
     }
     

  3. 如果函数的返回值时类A的对象时，则函数返回时，A的复制构造函数将被调用

• 为什么要自己写复制构造函数

  • 后续会讲解

类型转换构造函数

• 目的
  • 实现类型的自动转换
• 特点
  • 只有一个参数
  • 不是复制构造函数
• 编译系统会自动调用➡️转换构造函数➡️建立一个临时对象/临时变量

class Complex{
  public:
  	double real,imag;
  	Complex(int i){//类型转换构造函数
      cout<<"IntConstructor called"<<endl;
      real = i;
      imag = 0;
    }
  	Complex(double r, double i) //传统构造函数
    {
      real = r;
      imag = i;
    }
};

iint main()
{
  Complex c1(7,8);//对c1进行初始化，调用传统构造函数
  Complex c2 = 12; //对c2进行初始化，调用类型转换构造函数，不会生成一个临时对象
  c1 = 9; // 赋值语句，虽然赋值号两边类型不同，但是编译器没有报错。
  //编译器以9作为实参，调用类型转换构造函数，9被自动转换成一个临时Complex对象，赋值给c1
}

析构函数（Destructor）

• 回顾：构造函数
  • 成员函数的一种
  • 名字与类名相同
  • 可以有参数，不能有返回值
  • 可以有多个构造函数
  • 用来初始化对象
• 析构函数
  • 成员函数的一种
  • 名字与类名相同（在函数名之前加’~’）
  • 无参数，无返回值
  • 一个类最多只能有一个析构函数
  • 在对象消亡时，自动被调用
    • 在对象消亡前做善后工作
      • 释放分配的空间等
  • 定义类时没写析构函数，则编译器生成缺省析构函数
    • 不涉及释放用户申请的内存释放等清理工作
  • 定义了析构函数，则编译器不生成缺省析构函数

class String{
  private:
  	char *p;
  public:
  String(){
    p = new char[10];
  }
  ~String();
};

String::~String(){
  delete [] p;
}

• 析构函数和数组
  • 对象数组生命周期结束时，对象数组的每个元素的析构函数都会被调用
• 析构函数和运算符delete
  • delete运算导致析构函数调用
• 例题总结
  • 先被构造的对象，最后被析构掉（平级的情况下）
  • 构造函数和析构函数在不同编译器中
    • 个别调用情况不一致
      • 编译器有bug
      • 代码优化措施
    • 课程中讨论的是C++标准的规定，不牵扯编译器的问题

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

基本概念

• 静态成员：在说明前面+static关键字的成员，有静态成员变量和静态成员函数
• 普通成员变量每个对象有各自的一份，而静态成员变量一共一份，所有对象共享。
• sizeof运算符不会计算静态成员变量
• 普通成员函数必须具体作用于某个对象，而静态成员函数并不具体作用于某个对象
• 静态成员不需要通过对象就能访问
• 静态成员变量本质上是全局变量
• 静态成员函数本质上是全局函数
• 设置静态成员这种机制，目的是将和某些类紧密相关的全局变量和函数写进类中，看上去像一个整体，易于维护和理解

如何访问静态成员

1. 类名::成员名
2. 对象名.成员名
3. 指针->成员名
4. 引用.成员名

静态成员示例

• 考虑一个需要随时知道矩形总数和总面积的图形处理程序
• 可以用全局变量来记录总数和总面积（造成变量和类之间的关系不直观，且变量能够被其他类访问，存在一定风险）
• 用静态成员将这两个变量封装进类中，更容易理解和维护
• 必须在定义类的文件中对静态成员变量进行一次说明or初始化，否则编译能通过，链接不能通过

注意事项

• 在静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数
• 考虑到复制构造函数的影响

成员对象和封闭类

成员对象

• 一个类的成员变量是另一个类的对象
• 包含成员对象的类叫封闭类（Enclosing）

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;
}

• 如果CCar类不定义构造函数，则：

  • CCar car;//error➡️编译错误
    

  • 编译器不知道car.type该如何初始化

  • car.engine的初始化没有问题，可以用默认构造函数

• 生成封闭类对象的语句➡️明确“对象中的成员对象”➡️如何初始化

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

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

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

    {

    ……

    }

  • 成员对象初始化列表中的参数

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

调用顺序

• 当封闭类对象生成时
  • 执行所有成员对象的构造函数
  • 执行封闭类的构造函数
• 成员对象的构造函数调用顺序
  • 和成员对象在类中的说明顺序一致
  • 与在成员初始化列表中出现的顺序无关
• 当封闭类对象消亡时
  • 执行封闭类的析构函数
  • 执行成员对象的析构函数
• 先构造的后析构，后构造的先析构

友元

友元函数

• 一个类的友元函数可以访问该类的私有成员

class CCar; // 提前声明CCar类，以便后面CDriver类使用
class CDriver{
  public:
  void ModifyCar(CCar* pCar); //改装汽车
};
class CCar{
  private:
  	int price;
  friend int MostExpensiveCar(CCar cars[],int total); //声明友元
  friend void CDriver::ModifyCar(CCar *pCar);
}

void CDriver::ModifyCar(CCar *pCar)
{
  pCar->price +=1000; //汽车改装后价值增加
}
int MostExpensiveCar(CCar cars[],int total)//求最贵的汽车的价格
{
  int tmpMax = -1;
  for(int i = 0; i < total;++i)
    if(cars[i].price > tmpMax)
      tmpMax = cars[i].price;
  return tmpMax;
}
int main()
{
  return 0;
}

• 可以将一个类的成员函数（包括构造，析构函数）定义成另一个类的友元

class B{
  public:
  	void function();
};

class A{
  friend void B::function();
};

友元类

• A是B的友元类➡️A的成员函数可以访问B的私有成员
  • 友元类之间的关系，不能传递，不能继承

class CCar{
  private:
  	int price;
  friend class CDriver; //声明CDriver为友元类
};
class CDriver{
  public:
  	CCar myCar;
  void ModifyCar(){
    myCar.price += 1000; //CDriver是CCar的友元类➡️可以访问其私有成员
  }
};
int main(){return 0;}

this指针

this指针作用

• 指向成员函数所作用的对象
• 非静态成员函数中可以直接使用this来代表指向该函数作用的对象的指针

class Complex{
  public:
  	double real,imag;
  	void Print(){
      cout<<real<<","<<imag;
    }
  Complex(double r, double i):real(r),imag(i){ }
  Complex AddOne(){
    this->real++; //=real++
    this->Print();//=Print()
    return *this;
  }
};

int main()
{
  Complex c1(1,1),c2(0,0);
  c2 = c1.AddOne();
  return 0;
}

class A{
  int i;
  public:
  	void Hello(){cout<<"hello"<<endl;}
};//编译器把该成员函数编译成机器指令后，会变成
//void Hello(A *this){cout<<"hello"<<endl;}
//如果Hello函数变成 void Hello(){cout<<i<<"hello"<<endl;}
//就会出错

int main()
{
  A *p = NULL;
  p->Hello(); //结果会怎样？
}//输出：hello
//编译器把该成员函数编译成机器指令后，会变成
//hello(p)

注意事项

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

常量对象、常量成员函数和常引用

常量对象

• 如果不希望某个对象的值被改变，则定义该对象的时候可以在前面加const关键字

常量成员函数

• 在类的成员函数说明后面可以加const关键字，则该成员函数成为常量成员函数
• 常量成员函数执行期间不应修改其所作用的对象。因此，在常量成员函数中不能修改成员变量的值（静态变量除外），也不能调用同类的非常量成员函数（静态成员函数除外）

class Sample
{
  public:
  	int value;
  	void GetValue() const;
  	void func(){};
  	Sample(){}
};
void Sample::GetValue() const
{
  value = 0;//wrong
  func();//wrong
}

int main(){
  const Sample o;
  o.value = 100; //err,常量对象不可以被修改
  o.func();//err常量对象上面不能执行非常量成员函数
  o.GetValue();//ok
  return 0;
}

常量成员函数的重载

• 两个成员函数，名字和参数表都一样，但是一个是const一个不是，算重载

常引用

• 引用前面可以加const关键字，成为常引用。不能通过常引用，修改其引用的变量

const int & r = n;
r = 5;//error
n = 4;//ok

• 对象作为函数的参数时，生成该参数需要调用复制构造函数，效率比较低。用指针做参数，会让代码的可读性变差
• 所以可以用对象的引用作为参数。
• 但对象引用作为参数有一定的风险，若函数中不小心修改了形参，则实参也会跟着改变，如何避免？
• 所以可以用对象的常引用作为参数
• 这样函数中就能确保不会出现无意中更改形参值的语句了

练习题

注：填空题在Coursera提交时，文件中只需出现填进去的内容即可

Quiz 1

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<string>
#include<string.h>
using namespace std;
class A {
public:
    int val;
    A (int n = 0){val = n;}
    A & GetObj(){
        return *this;
    }
};
int main() {
    A a;
    cout << a.val << endl;
    a.GetObj() = 5;
    cout << a.val << endl;
}

Quiz 2

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<string>
#include<string.h>
using namespace std;
class Sample{
public:
    int v;
    Sample(int n):v(n) { }
    Sample(const Sample &a)
    {
        v = a.v*2;
    }
};
int main() {
    Sample a(5);
    Sample b = a;
    cout << b.v;
    return 0;
}

Quiz 3

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<string>
#include<string.h>
using namespace std;
class Base {
public:
    int k;
    Base(int n):k(n) { }
};
class Big {
public:
    int v;
    Base b;
    Big(int n = 5):v(n),b(n){ };
};
int main() {
    Big a1(5); Big a2 = a1;
    cout << a1.v << "," << a1.b.k << endl;
    cout << a2.v << "," << a2.b.k << endl;
    return 0;
}

Quiz 4 魔兽世界之一：备战

#include <iostream>
#include <cstdio>
#include <string>
using namespace std;
const int WARRIOR_NUM = 5;
/*
string Warrior::names[WARRIOR_NUM] = { "dragon","ninja","iceman","lion","wolf" };
红方司令部按照 iceman、lion、wolf、ninja、dragon 的顺序制造武士。
蓝方司令部按照 lion、dragon、ninja、iceman、wolf 的顺序制造武士。
*/

class Headquarter;
class Warrior
{
private:
    Headquarter * pHeadquarter; //指向英雄所属阵营的指针
    int kindNo;//武士的种类编号 0 dragon 1 ninja 2 iceman 3 lion 4 wolf
    int no;//英雄编号
public:
    static string names[WARRIOR_NUM]; //存放5种职业名字的数组
    static int initialLifeValue [WARRIOR_NUM]; //存放不同英雄的起始生命值（从输入中采集）
    Warrior( Headquarter *p,int no_,int kindNo_);//构造函数
    void PrintResult(int nTime); //执行打印数据的工作，若无法继续创建则输出结束并停止
};

class Headquarter
{
private:
    int totalLifeValue;
    bool stopped;
    int totalWarriorNum;
    int color;
    int curMakingSeqIdx; //当前要制造的武士是制造序列中的第几个
    int warriorNum[WARRIOR_NUM]; //存放每种武士的数量
    Warrior * pWarriors[1000];//和每个创建的英雄建立链接
public:
    friend class Warrior;
    static int makingSeq[2][WARRIOR_NUM];//武士的制作序列，按阵营的不同分成两个
    void Init(int color_, int lv); //初始化阵营需要颜色和总血量
    ~Headquarter();
    int Produce(int nTime); //创建英雄，输入时间
    string GetColor();
};

Warrior::Warrior(Headquarter *p, int no_, int kindNo_) {
    no = no_;
    kindNo = kindNo_;
    pHeadquarter = p;
}

void Warrior::PrintResult(int nTime) {
    string color = pHeadquarter->GetColor();
    printf("%03d %s %s %d born with strength %d,%d %s in %s headquarter\n",
            nTime, color.c_str(), names[kindNo].c_str(),no,initialLifeValue[kindNo],
            pHeadquarter->warriorNum[kindNo],names[kindNo].c_str(),color.c_str()); // string 在printf中输出的函数调用c_str()
}

void Headquarter::Init(int color_, int lv) {
    color = color_;
    totalLifeValue = lv;
    totalWarriorNum = 0;
    stopped = false;
    curMakingSeqIdx = 0;
    for (int i = 0; i < WARRIOR_NUM; i++) {
        warriorNum[i] = 0;
    }
}

Headquarter::~Headquarter() {
    for (int i = 0; i < totalWarriorNum; i++) {
        delete pWarriors[i];
    }
}

int Headquarter::Produce(int nTime) {
    if(stopped)
        return 0;
    int searchingTimes = 0;
    while(Warrior::initialLifeValue[makingSeq[color][curMakingSeqIdx]] > totalLifeValue &&
            searchingTimes < WARRIOR_NUM)
    {
        curMakingSeqIdx = (curMakingSeqIdx + 1) % WARRIOR_NUM;
        searchingTimes++;
    }
    int kindNo = makingSeq[color][curMakingSeqIdx];
    if(Warrior::initialLifeValue[kindNo] > totalLifeValue)
    {
        stopped = true;
        if(color == 0)
            printf("%03d red headquarter stops making warriors\n",nTime);
        else
            printf("%03d blue headquarter stops making warriors\n",nTime);
        return 0;
    }
    //排除所有其他条件后，开始制作士兵
    totalLifeValue -= Warrior::initialLifeValue[kindNo];
    curMakingSeqIdx =( curMakingSeqIdx + 1) % WARRIOR_NUM;
    pWarriors[totalWarriorNum] = new Warrior(this,totalWarriorNum+1,kindNo);
    warriorNum[kindNo]++;
    pWarriors[totalWarriorNum]->PrintResult(nTime);
    totalWarriorNum++;
    return 1;
}

string Headquarter::GetColor() {
    if(color == 0)
        return "red";
    else
        return "blue";
}

string Warrior::names[WARRIOR_NUM] = {"dragon","ninja","iceman","lion","wolf"};
int Warrior::initialLifeValue[WARRIOR_NUM];
int Headquarter::makingSeq[2][WARRIOR_NUM]={{2,3,4,1,0},{3,0,1,2,4}};//两个司令部武士的制作顺序序列

int main()
{
    int t;
    int m;
    Headquarter RedHead,BlueHead;
    scanf("%d", &t); //读取case数
    int nCaseNo = 1;
    while(t--){
        printf("Case:%d\n",nCaseNo++);
        scanf("%d",&m);//读取基地总血量
        for (int i = 0; i < WARRIOR_NUM; i++) {
            scanf("%d",&Warrior::initialLifeValue[i]);
        }
        RedHead.Init(0,m);
        BlueHead.Init(1,m);
        int nTime = 0;
        while (true){
            int tmp1 = RedHead.Produce(nTime);
            int tmp2 = BlueHead.Produce(nTime);
            if( tmp1 == 0 && tmp2 == 0)
                break;
            nTime++;
        }
    }
    return 0;
}
//老师给的答案读了好几遍，大概捋顺了……
//现阶段自己根本写不出来这种程序，在第一步抽象出两个类这块就感觉很困难
//慢慢加油吧……