首页 > 编程语言 >C++总结

C++总结

时间：2024-11-07 23:45:10浏览次数：3  
标签：总结 函数 基类 多态 C++ 派生类 public 构造函数

目录

一、面向对象的三大特性

二、引用

2.1 概念

2.2特性

三、类与对象

3.1概念

3.2 类的内容

3.3对象的创建

四、构造函数与析构函数

五、封装

六、继承

6.1概念与基础使用

6.2 继承权限

6.2.1 权限修饰符

6.2.2 继承权限

6.3构造函数

6.3.1 派生类与基类的构造函数关系

6.3.2 解决方法

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

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

1）透传构造

2）委托构造

3）继承构造

6.4 多重继承

6.4.1概念

6.4.2可能出现的问题

6.4.2.1 问题1-重名问题

6.4.2.2 问题2-菱形继承

七、多态

7.1 什么是多态？

7.2 多态的概念

7.3 函数覆盖

7.4 虚函数的定义

7.5 多态实现

7.6 多态的原理

7.7 虚析构函数

一、面向对象的三大特性

封装->继承->多态

二、引用

2.1 概念

引用就是给某个变量或常量起别名，对引用进行操作与操作原变量或常量完全相同。

int main（）
{
    int a  =  10086;
    int &b = a ; //  b = 10086
    b ++ ; // b = 10087
}

2.2特性

1）可以改变引用的值，但不能再次成为其他变量的引用

int main()
{
    string str1 = "Gagahao";
    string & str2 = str1; 
    // string & str3 = str2;  错误 str2已经是str1的引用了，不能被str3再次引用
}

2）声明引用时必须初始化

int main（）
{
    //int &a ;
}

  1. 声明引用时不能初始化为NULL

int main()
{
    //int &a = NULL;
}

4)声明引用的时候，初始化的值可以是纯数值，但是此时要使用const关键字修饰引用，表示改引用为常量引用。这样的引用的值不可变。

int main()
{
    const int &num = 666； //常量引用
    //num = 123； //错误 常量引用的数值不可变  
}

5）可以对指针建立引用

int main()
{
    int a = 1;
    int &b = a;
    int *c = &b;    // C同时指向了A和B
}

6）可以使用const修饰引用，此时如果原变量的值改变，引用的值也会发生改变

int main()
{
    int a = 2;
    const int &b = a;
    
    a++；
    
    cout << a << " " << &a << endl; // 3 0x61fe88
    cout << b << " " << &b << endl; // 3 0x61fe88
}

三、类与对象

3.1概念

类：类是一个抽象的概念，用于描述同一类对象的特点。

对象：根据类的概念所创造的实体。

3.2 类的内容

类中最基础的内容包括两部分，一个是属性(成员变量)，一个是行为(成员函数)。

成员 = 成员函数+成员变量。

3.3对象的创建

C++中存在两种类型的对象：

栈内存对象：对象所在的{}执行完成后，自动被销毁。调用栈内存对象时用"."

堆内存对象：必须使用关键字new创建，使用关键字delete销毁。如果没有及时销毁的话，会造成内存泄漏,调用堆内存对象时用"->".

四、构造函数与析构函数

构造函数

析构函数

函数名称为类名

函数名称为~类名

功能为创建对象并初始化

功能为在对象销毁时回收资源

调用事件：在创建对象时调用

在对象销毁时自动被调用

有参数，支持重载和默认值

无参数，不支持重载和默认值

class Student
{
private:
   string name;
public:
    Student（string name）:name(name){}
    ~Student(){}
}
int main()
{
    Student *s1 = new Student("赵华润");
    ......//内部执行代码
    delete s1;
    return 0;
}

注意：如果我们不手动编写构造函数时，编译器会自动添加一个无参且函数体为空的构造函数。相同，如果不手写析构函数，编译器也会为我们添加上述代码中的析构函数。

五、封装

概念：封装是将类内的某些信息隐藏(私有化)，并提供一些外部访问接口，可通过外部访问接口来访问这些信息。

class MobilePhone
{
private: 
    string brand;
public:
    string get_brand() // getter：读函数
    {
        return brand;
    }
    
    void set_brand(string b) // setter：写函数
    {
        brand = b;
    }
}；
 
 int main()
{
    MobilePhone mp1;
    mp1.set_brand("钛合金8848");
    cout << mp1.get_brand() << endl;  //钛合金8848
    return 0；
}

六、继承

6.1概念与基础使用

继承就是在一个已经存在的类的基础上新建立一个类，新创建的类拥有之前类的特性。体现了代码复用的思想。

  • 已经存在的类被称为“基类 Base Class”或“父类”
  • 新创建的类被称为“派生类”或“子类Sub Class”

class Father
{
public：
    void func（）
    {
        cout << "叭叭叭" << endl;
    }
}；

class Son：public Father
{
public：
}；

int main（）
{
    Son *s1 = new Son;
    son->func(); //"叭叭叭"
    delete s1;
    return 0;
}

6.2 继承权限

6.2.1 权限修饰符

类内

派生类中

全局

private

√

×

×

protected

√

√

×

public

√

√

√

6.2.2 继承权限

1）公有继承

派生类从基类中继承的成员的权限不发生改变。

2）保护继承

在保护继承中，基类的所有成员均可以被派生类继承。但是基类的私有成员无法被派生类直接访问，基类的保护成员和公有成员继承到派生类中作为派生类的保护成员。

3）私有继承

在私有继承中，基类的所有成员均可以被派生类继承，但是基类的私有成员无法被派生类直接访问，基类的保护成员和公有成员继承到派生类中作为派生类的私有成员。

6.3构造函数

构造函数和析构函数不能被继承

6.3.1 派生类与基类的构造函数关系

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

槽函数！！！

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

标签：总结,函数,基类,多态,C++,派生类,public,构造函数
From： https://blog.csdn.net/weixin_63791423/article/details/143610389

相关文章

  • 2024-2025-1 20242407《网络》第二周学习总结
    2024-2025-120242407《网络》第二周学习总结教材学习内容总结教材学习中的问题和解决过程问题一：对于维吉尼亚密码的加密方式不是很理解解决方法：通过询问AI基于AI的学习......
  • [题目总结 #1] 静态序列区间查询问题（未完）
    [题目总结#1]静态序列区间查询问题前言不久前遇到一批这种题，我发现自己思路很单一，只想着莫队、分块、线段树，但是其实可能有其他巧妙的做法，而且就算是用分块、线段树维护的东西也有我没想到的。总体来说，在这种题上，自己的思维太固化、自己太依赖思维惯性，又不熟悉各种套路。于是......
  • 【C++11】智能指针
    一.为什么需要智能指针        学习C++的人，一直在接触裸指针，一边感受着它的强大，一边感受着它的坑爹。当然，坑不坑爹在于开发者，指针本身近乎完美，但奈何用的人比较猥琐，给自己埋下无数的坑，还哭喊着指针不好用，那么今天要介绍的智能指针可以释放大家在使用裸指针时的一些压......
  • 【C++】C++11之函数对象，Lambda表达式和functional函数对象类型
    知识的学习在于点滴记录，坚持不懈函数对象        重载了函数调用运算符()的类的对象，即为函数对象。        std::function由上文可以看出：由于可调用对象的定义方式比较多，但是函数的调用方式较为类似，因此需要使用一个统一的方式保存可调用对象或者传递可......
  • C++循环引用指的是什么，在使用过程当中需要注意什么问题
    C++中的循环引用是指两个或多个对象相互持有对方的引用，导致这些对象无法被自动释放，从而造成内存泄漏。循环引用主要发生在使用智能指针（如 std::shared_ptr）管理对象生命周期时。以下是循环引用的具体解释及其使用中需要注意的问题：循环引用的形成当两个对象A和B互相持......
  • 2024/11/5日工作总结
    学习JS基础知识：1.引入方式：点击查看代码<!DOCTYPEhtml><htmllang="en"><head><metacharset="UTF-8"><title>Title</title></head><body><!--内部脚本--><!--<script>alert(......
  • C++ 委托实现
    MyDelegate.h#pragmaonce#include<typeinfo.h>#include<list>#include<vector>namespaceDelegate{ //IDelegate提供接口的基类 template<typenameReturnType,typename...ParamType> classIDelegate { public: IDelegate(){} ......
  • 2024年11月7号总结
    今天在课余又学了javaWeb的一些内容，把MySQL重新下好了DQL聚合函数聚合函数：将一列数据作为一个整体，进行纵向计算count 统计数量max/min 最值sum 求和avg 平均数selectcount(id)fromstu;括号内的列名不能为空，有空的项不算数count取值：或者主键selectmax（math）fromstu；......
  • 方法及其优化技巧总结
    公式题：区间贡献拆为点贡献。公式全部拆开求和算值。和积和区间最大值满足单调，排序后计算。max动态规划：先打暴力再优化。看数据范围猜测状态。前i个选了j个.多个选择考虑背包，搜索：搜素题大多是剪纸多，加记忆化，分类讨论都需要+1-1*2看到数据范围非常小无非就是高复杂度的......
  • CSP-JS总结（修订版）
    CSP-J/S2024游记初赛CSP-J开头的int确实挺搞心态的，组合排列也放得挺前，不过顺利做出来了做完颓了。结果错挺多的，赛后感觉还是不够细致，下午的比赛要更细心一点小图灵：89.5怎么了呢？连90都上不了了CSP-S看题然后发现一堆不会做有点懵，感觉阅读程序不是很能读得懂然后完......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99