C++总结

// 基类
class Father
{
private:
    string name = "孙";
public:
    // 有参构造函数
    Father(string name):name(name){}

    string get_name(){
        return name;
    }
};

// 派生类
class Son:public Father
{
public：
};

int main()
{
//    Son s; // 找不到基类的无参构造函数
//    Son s("张"); // 没有匹配的构造函数
    return 0;
}

6.3.2 解决方法

6.3.2.1 补充基类的无参构造函数

class Father
{
private:
    string name = "孙";
public:
    // 补充基类无参构造函数
    Father()
    {
        cout << "构造函数被调用了" << endl;
    }
    // 有参构造函数
    Father(string name):name(name){}

    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
public:
    // 编译器自动添加的构造函数
    Son():Father()
    {
        cout << "派生类构造函数被调用了" << endl;
    }
};

int main()
{
    Son s; 
    return 0;
}

6.3.2.2手动在派生类中调用基类构造函数

1）透传构造

class Father
{
private:
    string name = "孙";
public:
    // 有参构造函数
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};

class Son:public Father
{
public:
    // 透传构造
    Son():Father("张"){}
    // 派生类有参构造函数，调用基类有参构造函数
    Son(string fn):Father(fn){}
};

int main()
{
    Son s;
    cout << s.get_name() << endl; //张

    Son s1("王");
    cout << s1.get_name() << endl;//王

    return 0;
}

2）委托构造

一个类的构造函数可以调用这个类的另一个构造函数，但是要避免循环委托。

class Father
{
private:
    string name = "孙";
public:
    // 有参构造函数
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
public:
    // 委托构造
    Son():Son("张"){}
    // 派生类有参构造函数，调用基类有参构造函数
    Son(string fn):Father(fn){}
};

int main()
{
    Son s;
    cout << s.get_name() << endl; //张
    return 0;
}

3）继承构造

只需要一句话，就可以自动给派生类添加n（n为基类构造函数的个数（不包含默认无参构造函数））个构造函数。并且每个派生类的构造函数的格式都与基类相同，每个派生类的构造函数都通过透传构造调用对应格式的基类构造函数。

class Father
{
private:
    string name = "孙";
public:
    Father():Father("张"){}
    // 有参构造函数
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};
// 派生类
class Son:public Father
{
public:
    using Father::Father;
};

int main()
{
    Son s;
    cout << s.get_name() << endl;
    return 0;
}

6.4 多重继承

6.4.1概念

一个派生类可以有多个基类。派生类对于每个基类的关系仍然可以看作是一个单继承。

class Sofa
{
public:
    void sit()
    {
        cout << "沙发可以坐着" << endl;
    }
};

class Bed
{
public:
    void lay()
    {
        cout << "床可以躺着" << endl;
    }
};

// 多重继承
class SofaBed :public Sofa,public Bed
{
public:
};

int main()
{
    SofaBed sb;
    sb.lay(); //床可以躺着
    sb.sit(); //沙发可以坐着
    return 0;
}

6.4.2可能出现的问题

6.4.2.1 问题1-重名问题

当多个基类具有重名成员时，编译器在编译的过程中会出现二义性的问题。

解决方式：使用基类的类名::方式调用。

class Sofa
{
public:
    void clean()
    {
        cout << "打扫沙发" << endl;
    }
};

class Bed
{
public:
    void clean()
    {
        cout << "打扫床" << endl;
    }
};

// 多重继承
class SofaBed :public Sofa,public Bed
{
public:
};


int main()
{
    SofaBed sb;
    sb.Sofa::clean();
    sb.Bed::clean();
    return 0;
}

6.4.2.2 问题2-菱形继承

当一个基类有多个派生类，且这些派生类又有一个共同基类时。就会出现二义性问题，这种继承方式称为菱形（钻石）继承。

有两种解决方式：

1. 使用基类的类名::方式调用

//跟上边代码差不多，自己补充

1. 使用虚继承

当出现虚继承时，Furniture类会生成一张虚基类表。这个表并不会占用任何对象的存储空间，属于Furniture类持有，在程序启动时加载进内存，表中记录了Furniture函数的调用地址偏移量。

Bed和Sofa对象会出现一个隐藏的成员变量指针，指向Furniture类中的虚基类表，占用对象四个字节。

SofaBed继承Sofa和Bed时，SofaBed类对象会同时拥有两个虚基类表指针成员，在调用时通过查表解决二义性。

class Furniture
{
public:
    void func()
    {
        cout << "家具厂里有家具" << endl;
    }
};

class Sofa:virtual public Furniture
{
public:
};

class Bed:virtual public Furniture
{
public:
};

// 多重继承
class SofaBed :public Sofa,public Bed
{
public:
};


int main()
{
    SofaBed sb;
    sb.func(); //家具厂里有家具
    return 0;
}

七、多态

7.1 什么是多态？

在面向对象编程中，我们通常将多态分为两种类型：静态多态（静态多态，也被称为编译时多态）和动态多态（动态多态，也被称为运行时多态）。这两种多态性都是多态概念的不同表现方式。

静态多态

• 静态多态是指在编译时就能确定要调用的方法，通过函数重载和运算符重载来实现。

动态多态

• 动态多态是指在运行时根据对象的实际类型来确定要调用的函数，通过继承和函数覆盖来实现。

静态多态发生在编译时，因为在编译阶段编译器就可以确定要调用的函数。

动态多态发生在运行时，因为具体调用那个函数是在程序运行时根据实际对象的实际类型来确定的。

7.2 多态的概念

多态可以理解为"一种接口，多种状态"只需要编写一个函数接口，根据传入的参数类型，执行不同的策略代码。

多态的使用有三个前提条件：

• 公有继承
• 函数覆盖
• 基类的引用/指针指向派生类对象

多态的优点：多态的优势包括代码的灵活性、可扩展性和可维护性更好。它能使代码更具有通用性，减少重复代码的编写，并且能够轻松的添加新的派生类或拓展现有的功能。

多态的缺点：缺点包括代码的复杂性，运行效率、不易读。当类的继承关系复杂使，理解和维护多态的代码会变得困难。多态在运行时会产生一些额外的开销。

7.3 函数覆盖

函数覆盖和函数隐藏比较相似，但是函数隐藏不支持多态，而函数覆盖是多态的前提条件。函数覆盖比函数隐藏有一下几点区别：

• 函数隐藏是派生类中存在与基类中同名同参的函数，编译器会将基类的同名同参数的函数进行隐藏。
• 函数覆盖是基类中定义了一个虚函数，派生类编写一个同名同参数的函数将基类中的虚函数进行重写并覆盖。注意：覆盖的基类函数必须是虚函数。

7.4 虚函数的定义

一个函数使用virtual关键字修饰，就是虚函数。虚函数是函数覆盖的前提。在Qt Creator中虚函数的函数名称使用斜体字。

class Animal
{
public:
    // 虚函数
    virtual void eat()
    {
        cout << "动物爱吃饭" << endl;
    }
};

虚函数具有以下性质：

• 虚函数具有传递性，基类中的覆盖的函数是虚函数，派生类中新覆盖的函数也是虚函数。

class Animal
{
public:
    virtual void eat()
    {
        cout << "动物爱吃饭" << endl;
    }
};

class Dog :public Animal
{
    // 覆盖基类中的虚函数，派生类的virtual关键字可写可不写
    void eat()
    {
        cout << "狗爱吃骨头" << endl;
    }
};

• 只有普通成员函数与析构函数可以声明为虚函数，但构造函数和静态成员函数不能声明为虚函数。

class Animal
{
public:
//  错误 构造函数不能声明为虚函数
//    virtual Animal(){} 

 // 错误 静态函数不能为虚函数
//    virtual static void testStatic()
};

• 在C++11中，可以在派生类的新覆盖的函数上使用override关键字验证覆盖是否成功。

#include <iostream>
using namespace std;


class Animal
{
public:
    virtual void eat()
    {
        cout << "动物爱吃饭" << endl;
    }

    void funHide()
    {
        cout << "测试：override关键字" << endl;
    }

};

class Dog :public Animal
{
    // 覆盖基类中的虚函数，派生类的virtual关键字可写可不写
    void eat()override
    {
        cout << "狗爱吃骨头" << endl;
    }
//    void funHide()override //错误 funHide不是虚函数
//    {
//        cout << "测试：override关键字" << endl;
//    }
};

7.5 多态实现

实现动态多态，需要有三个前提条件。

• 公有继承（已经实现）
• 函数覆盖（已经实现）
• 基类的指针/引用指向派生类对象

【思考】为什么要基类的指针指向派生类的对象呢？

• 实现多态：当使用基类的指针或引用指向派生类对象时，程序在运行时会根据对象的实际类型来调用相应的函数，而不是根据指针或引用的类型。
• 统一接口：基类的指针可以作为一个通用的接口，用于操作不同类型的派生类对象。这样可以让代码更灵活，减少重复代码的编写。

class Animal
{
public:
    // 虚函数
    virtual void eat()
    {
        cout << "动物爱吃饭" << endl;
    }
};

class Dog :public Animal
{
public:
    void eat()override
    {
        cout << "狗爱吃骨头" << endl;
    }
};


int main()
{
    Animal *a1 = new Dog;
    a1->eat();  // 狗爱吃骨头
    return 0;
}

我们也可以提供接口，参数设计为基类的指针或者是引用，这样这个函数就可以访问到此基类所有派生类的虚函数了。

#include <iostream>
using namespace std;


class Animal
{
public:
    // 虚函数
    virtual void eat()
    {
        cout << "动物爱吃饭" << endl;
    }
};

class Dog :public Animal
{
public:
    void eat()override
    {
        cout << "狗爱吃骨头" << endl;
    }
};

// 提供通用函数，形参为基类指针
void animal_eat1(Animal *a1)
{
    // 100 代码
    // 需要用到派生类的虚函数参与逻辑处理
    a1->eat();
}


// 提供通用函数，形参为基类引用
void animal_eat2(Animal &a1)
{
    a1.eat();
}

int main()
{
    Dog d1;
    Dog * d2 = new Dog;
    animal_eat2(d1);    // 狗爱吃骨头
    animal_eat1(d2);  // 狗爱吃骨头
    return 0;
}

7.6 多态的原理

具有虚函数的类会存在一张虚函数表，每个类的对象内部都会有一个隐藏的虚函数表指针成员，指向当前类的虚函数表。

多态实现流程

在代码运行时，通过对象的虚函数表指针找到虚函数表，在表中定位到虚函数的调用地址，从而执行对应的虚函数的内容。

7.7 虚析构函数

如果不使用虚析构函数，且基类指针或引用指向派生类对象，使用delete销毁对象时，只能触发基类的析构函数，如果在派生类中申请内存等资源，则会导致无法释放，出现内存泄漏的问题。

解决方案给基类的析构函数使用virtual修饰为虚析构函数，通过传递性可以把各个派生类的析构函数都变为虚析构函数，因此建议给一个可能为基类类中的析构函数设置成虚析构函数。

class Animal
{
public:
    // 虚析构函数
    virtual ~Animal()
    {
        cout << "析构函数Animal" << endl;
    }
};

class Dog :public Animal
{
public:
    ~Dog()
    {
        cout << "析构函数Dog" << endl;
    }
};

int main()
{
    Animal *a1 = new Dog;
    delete a1;
    return 0;
}

• QT补充
  1. QT课程定位

1. Qt的学习需要C++基础。

2. Qt是C++的实践课，C++的很多抽象理论可以在开发案例中体现。

3. Qt的API非常多且代码量大，千万不要死记硬背。

1. 1. QT可能用到的知识点（可能）
2. this指针结合多态
3. 容器（Map键值对、list列表）
4. 数据库
5. IO进程(多进程、多线程)
6. 网络编程(TCP/UDP)
7. 抽象类
   1. 提前预习的知识点

槽函数！！！

(得(de)槽函数者得(de)QT)