转换函数(conversion function)

  • 可以把"这种"东西，转化为"别种"东西。

  • 即Fraction ——> double

class Fraction {
public:
    Fraction(int num, int den = 1) :
        m_numerator(num), m_denominator(den) {
    }
    operator double()const {
        return ((double)m_numerator / m_denominator);
    }
private:
    int m_numerator;  //分子
    int m_denominator;//分母
};
Fraction f(3,5);
double d = 4 + f;

说明:

  • 编译器先去查找是否有支持的函数能让这行代码通过。
  • 是否有operator+(double,Fraction),重载了+号。
  • 没有，则看能否将f转换为double。找到了operator double()const。
  • 于是f变成了0.6。
std::cout << typeid(f).name()<<std::endl;//class Fraction
std::cout << d <<std::endl;//4.6

注意:

  • 我在侯捷老师的视频中的发现了一个小问题。
  • image-20220720231907092
  • 如上图所示(double)的位置写的不对，应任意写到后两个变量的前面，如我上面类的代码所示。

non-explicit-one-argument-ctor

  • 具有一个实参的构造函数()

  • 可以把"别种"东西，转化为"这种"东西。

  • 即double ——> Fraction

class Fraction
{
public:
    Fraction(int num,int den = 1):
        m_numerator(num),m_denominator(den){}

    Fraction operator+(const Fraction& f){
        return Fraction(...);
    }
private:
    int m_numerator;  
    int m_denominator;
};
Fraction f(3,5);
double d = 4 + f;

说明:

  • 可以看到在Fraction类中我们重载了+运算符，可以使两个Fraction对象进行相加。
  • 但是我们下面进行调用的时候使用的是一个整数与一个Fraction对象进行相加。
  • 此时调用的形式与我们的设计不同，于是编译器去看看能不能将4转换为Fraction，如果可以转换，则符合了我们的+重载。
  • 于是调用我们的构造函数Fraction(int num,int den = 1)，将4转换为Fraction，进行加法。

转换冲突

  • 此时，我们将上面两个例子中的两个成员函数整合。
class Fraction
{
public:
    Fraction(int num,int den = 1):
        m_numerator(num),m_denominator(den){}

    operator double()const {
        return ((double)m_numerator / m_denominator);
    }

    Fraction operator+(const Fraction& f){
        return Fraction(...);
    }
private:
    int m_numerator;  
    int m_denominator;
};
Fraction f(3,5);
double d = 4 + f;
  • 编译器报错，不知道该如何是好。
  • 是4——>Fraction，还是Fraction——>4。
  • 产生歧义。

explicit-one-argument ctor

  • 给构造函数添加explict关键字，此时"别种"东西无法转换为"这种"东西即Fraction对象。
  • 不让编译器去暗度陈仓地偷偷调用构造函数。
  • 只有真正需要构造的时候采取调用。
class Fraction
{
public:
    explicit Fraction(int num,int den = 1):
        m_numerator(num),m_denominator(den){}

    operator double()const {
        return ((double)m_numerator / m_denominator);
    }

    Fraction operator+(const Fraction& f){
        return Fraction(...);
    }
private:
    int m_numerator;  
    int m_denominator;
};
Fraction f(3,5);
double d = 4 + f;

说明:

  • 此时4向Fraction转换失败。f被转成double进行计算，结果为4.6

  • explicit多数用在构造函数处，少数还有在模板处。

标准库应用

image-20220721220738385

类指针类(pointer-like classes)

智能指针

  • 这个class创建的对象像指针。
  • 因为想要它比普通指针多做一些事情。
  • 即智能指针。

image-20220722175624295

注意:"->"这个符号很特别

  • 例如说，上图右侧中的 sp中的， 号,在使用后就会消失。
  • 但是sp->method(),我们可以看到，调用sp->在右侧的类中，返回px,再往下看px->method(),会发现，这里其实少了一个->，这里就体现出这个符号的特殊性了，得到的东西会继续用箭头符号作用上去。

迭代器

  • 在运算符上比智能指针需要重载更多运算符，处理更多功能。
  • 有特别功能的智能指针。
  • 主要用于遍历容器。

image-20220722181438891

  • 示例——标准库中的list迭代器
  • foo即data
  • 注意与上面智能指针重载运算符的对比。

image-20220722182803315

说明:

  • 左边方框中的内容等同于右边话蓝线的部分。

仿函数(function-like classes)

  • 设计一个类，让它的行为像函数。
  • 小括号操作符，就叫做函数调用操作符。
  • 所以如果有一个东西可以接受小括号操作符，就把这个东西称作函数，或者是一个像函数的东西。

image-20220731175954580

  • 具体的相关继承问题详见STL库部分。

namespace经验之谈

  • 分块开发，避免命名冲突。

模板(template)

类模板(class template)

  • 定义类的时候将允许使用者任意指定的类型抽出来。
  • 使用时需要进行类型的指定。

image-20220731184131481

函数模板(function template)

  • 使用不需要指定类型。
  • 编译器会自动进行实参推导。

image-20220731195049956

说明:

  • 首先编译模板。
  • 接着再次编译，判断stone类型的运算是否合法。

成员模板(member template)

  • 也就是模板的嵌套，模板中有模板。
  • 如下图黄色部分。

image-20220731195410159

说明: 黄色这一块是当前模板的一个成员，同时它自己也是个模板。所以它就叫做成员模板。

  • T1,T2可以变化，U1,U2也可以变化。

在STL标准库中会大量出现成员模板，先来一个小示例:

解释:

  • 鲫鱼类继承自鱼类，麻雀类继承自鸟类。
  • 使用鲫鱼和麻雀构成的pair，然后拷贝到到鱼类和鸟类构成的pair，这样是可以的。反之则不行。
  • 允许或不允许限制的条件为: 下方代码中的构造函数。(父类指针可以指向子类对象)
  • 这样，让构造函数更有弹性 。
template<calss T1,class T2>
struct pair{
    ...

    template<class U1,class U2>
    pair(const pair<U1,U2>&p):first(p.first),second(p.second){}
};
  • shard_ptr内的使用

image-20220925210959276

  • 同普通指针的，父类指针可以指向子类对象。
  • 补充:C++ Upcast(向上造型）
    • up-cast为向上构造
    • down-cast为向下构造

模板特化(specialization)

全特化

  • 泛化的反面就是特化
  • 泛化(又叫全泛化)指的是用的时候指定类型。
  • 根据特定的类型进行特殊处理，类似于函数重载。

image-20220925212047290

// 泛化
#include <iostream>
using namespace  std;

// 泛化
template<class  Key>
struct hash1{};

// 特化
template<>
struct hash1<char>{
    size_t operator()(char x)const {
        return x;
    }
};

template<>
struct hash1<long>{
    size_t operator()(long x)const {
        return x;
    }
};

int main(void){
    // 调用
    hash1<long>()(1000);// 构造一个hash的临时对象，传递参数1000,找到上面的特化long

    return 0;
}
  • 与全特化对应的是偏特化(局部特化)

偏特化

  • 个数上的偏
    • 从左边开始绑定，不能跳。

  • 范围上的偏
    • 例如，从接收任意范围T，到接收指针T*

模块模板参数(tempalte template parameter)

  • 即，模板的参数又是一个模板

image-20221223192522559

  • 如上图所示，传递任意的容器与元素类型进行组合
    • 其中第一个打岔的部分，光看语法上并没有问题，但是，实际上在我们定义容器的时候有多个默认参数，这样做是无法通过编译的。
    • 但是第二个OK

这个不是模板模板参数

image-20221223205927384

  • 调用中我们使用第二种方法，指明第二模板参数，其实这个list< int >就已经不是模板了，已经指明了,即使它是用模板设计出来的东西。
  • 但是已经绑定，写死，list中的元素类型为int;
  • 注意与本小节第一张图对比。
  • 所以temp<class T,class Sequence = deque< T >>第二个参数，不是模板模板参数。

可变参数模板(variadic templates-since)

  • 模板可接收任意个参数，详见下方示例:
#include  
#include 
using namespace std;

void print(){}

// 分为一个和一包 
template
void print(const T& firstArg,const Types&...args) {
    cout<(377),42);
    return 0;
}

自动类型推导(auto)

  • 示例
list<string>c;
//...
list<string>::iterator ite;
ite = find(c.begin(),c.end(),target);
  • 使用实例
auto ite = find(c.begin(),c.end(),target);//  定义使用时就赋值
  • 错误使用
auto ite;// 编译器不能也无法知道这个ite是什么，无法进行推导
ite = find(c.begin(),c.end(),target);

更简洁的for(ranged-base for)

for(decl: coll){
    statement
}
  • 示例
vector<double>vec;
//...

// pass by value 传值
for(auto elem:vec){
    cout<<elem<<endl;
}
// pass by reference 传引用——改变原来的东西
for(auto& elem:vec){
    elem *=3;
}

引用(reference)

  • 引用一定要设初值，且之后无法再代表其它值。

  • 示例

    int x = 0;
    int* p = &x;// p指向x 
    int& r = x;// r代表x 

    int x2 = 5;

    r = x2;// x r都为5，相当于将值5赋给x 

    int& r2 = r;
  • 有趣的一点: 编译器制造出的假象
    • 大小相同，地址也相同
sizeof(r) == sizeof(x);
&x == &r;
  • referece 就是一种漂亮的pointer
    • 多用于参数传递——传引用

image-20221223233254829

  • same signature——相同函数签名，二者无法并存
    • 函数名和参数列表包括后面的const为signature(函数签名)
    • const 是函数签名(signature)的一部分
    • 编译器不知道你调用的是谁
double imag(const double& im){...}
double imag(const double im){...}

对象模型(Object Model)

继承下的构造与析构

  • 构造——由内而外
    • 子类构造时，会先执行父类的默认构造函数，编译器会默认加上并执行。
  • 析构——由外而内
    • 子类析构时，会先析构掉自己执行完后，然后指定父类的默认析构函数，同样由编译器添加并执行。

复合下的构造与析构

  • 构造——由内而外

  • 析构——由外而内

继承+复合下的构造与析构

  • 构造——由内而外
    • 但是此时内有两个，也许在不同编译器上的实现手法不同，可能会导致顺序不同。
  • 析构——由外而内
    • 同上，要注意的是，上面先构造的，会后析构。

虚指针与虚函数表(vptr & vtbl）

  • 虚指针指向虚函数表，虚函数表中都是函数指针。
  • 虚函数的调用&执行，如下图所示:

image-20221224141619682

  • 调用虚函数的过程为动态绑定——即多态，父类指针可以接收具体的子类对象，即根据具体是哪个子类，调用该虚函数具体的形式。

    • 调用指针->向上转型(转为具体的子类)->调用虚函数

  • 补充:

    • 继承父类，函数，继承的是调用权。
    • 父类的虚函数子类也一定要有。
    • 父类和子类中可以出现同名的函数，但实际上不是同一个。

this pointer

  • 类的成员函数中，默认会有一个this指针传递进来。由编译器自己处理。

image-20221224221135995

补充

const

  • 修饰成员函数——即放到成员函数参数列表后:

    • 表明该成员函数不打算修改成员变量的值
    • 让编译器帮忙把关，如果修改了，则无法通过编译。

  • 常量对象不能调用非常量成员函数，反之，可以。

    • 但是，当成员函数的const版本和非const版本都存在，则常量对象只能调用const版本，非const对象只能调用非const版本。

  • 能加const就加const

  • const属于函数签名的一部分

  • 示例: 标准库中的string，区分调用者的意图:

image-20221224232341559

new & delete

  • 三种new——参考: C++ new的三种面貌

    • new (operator): 即关键字new,实际在堆中分配内存时，调用下面两个
    • operator new: 用于申请堆内存空间，类似于C语言中的malloc()
    • pleacement new: 即放置new，在人为指定的特定内存创建对象，是一个特殊的operator new,对其进行了重载。

  • 调用new实际上被分解为三条语句——表达式行为不能被修改，也就是分解的这件事情不能被修改，但是分解下去调用的函数可以被重载

//调用
MyComplex *pc = new MyComplex(1,2);

void* temp = operator new(sizeof(MyComplex));// 分配内存-相当于调用malloc(n)
pc = static_cast<MyComplex*>(temp);//转型
pc->MyComplex::MyComplex(1,2);//调用构造函数
  • delete实际上被分解为两条语句
delete pc;

Complex::~Complex(pc);
operator delete(pc);//（即 调用free）

重载::operatpr new,::operator delete,::operator new[],::operator delete[]

image-20221225100615799

重载member operator new/delete

  • 一个对象

image-20221225102320444

重载member operator new[]/delete[]

  • 数组

image-20221225101300115

示例

  • 若无成员函数就调用globals
  • 也可以强制使用globals

image-20221225101419034

  • 这个多出来的4是一个计数器，数组中的元素个数(gnu c)
    • 无论你是否重载，这个计数器都会存在。

image-20221225102055964

重载pleacement new,pleacement delete

  • 类的成员函数，可以重载多个版本，每一个版本都要有独一无二的参数列。

    • 第一个参数必需为size_t——大小
    • 其余参数为使用时()中指定的参数，例如下方示例中的300,'c'

  • 重载operator delete()后，绝对不会被delete调用，只有当new所调用的构造函数抛出异常，才会调用这些版本的operator delete()

    • 不是必须的，可重载，可不重载

  • 示例

Foo* pf = new(300,'c')Foo;

image-20221225190302180

basic_string使用new

  • 当我们想在分配内存的时候无声无息的多分配一些，可以借用下面的思想。

image-20221225182352033