C++基础知识四

最新推荐文章于 2024-07-04 11:10:43 发布
最新推荐文章于 2024-07-04 11:10:43 发布
阅读量1k 收藏
点赞数
文章标签： 开发语言 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43296982/article/details/123891367
版权

一、多态
1.1 概念：在基类指针指向基类对象的时候，就是使用基类的方法和属性，基类指针指向派生类对象的时候，就使用派生类对象和属性，
产生条件：1）要有继承 2）要有虚函数重写（发生在不同作用域中，函数原型相同） 3）基类指针指向派生类对象

#include <iostream>
using namespace std;

class Parent
{
    public:
        virtual void show()   //这里要变成虚函数
        {
            cout<<"this is parent"<<endl;
        }
};

class Child:public Parent      //1.继承
{
    public:
        void show()
        {
            cout<<"this is child"<<endl;    //2.要有虚函数重写
        }
};

int main(int argc, char const *argv[])
{
    Child c;
    Parent p;
    p = c;    //向上转型

    Parent *p1 = new Child;   //3.基类指针指向派生类对象
    p1->show();               //静态联编,编译器会根据p1的类型(Parent)调用Parent里面的show函数

    delete p1;
    p1 = new Parent;
    p1->show();   //相同的语句有不同的执行结果(多态)

    return 0;
}

在这里插入图片描述
1.2 多态的基本原理
在这里插入图片描述

#include <iostream>
using namespace std;

class Parent
{
    public:
        int a;
        virtual void show()   //这里要变成虚函数
        {
            cout<<"this is parent"<<endl;
        }
};

class Child:public Parent
{
    public:
        void show()
        {
            cout<<"this is child"<<endl;
        }
};

int main(int argc, char const *argv[])
{
    Child c;
    Parent p;
    
    cout<<sizeof(c)<<endl;
    cout<<sizeof(p)<<endl;
    cout<<"Parent对象的地址"<<&p<<endl;
    cout<<"成员变量a的起始地址"<<&p.a<<endl;
    cout<<"child对象的地址"<<&c<<endl;
    cout<<"child成员变量的起始地址"<<&c.a<<endl;
    return 0;
}

在这里插入图片描述
1.3 虚析构函数
根据析构规则，只能从当前基类开始往上调用析构函数，并不能调用派生类中的析构函数，通过这种方式，可以正确调用析构函数

#include <iostream>
using namespace std;

class Parent
{
    public:
        Parent()
        {
            cout<<"parent的构造函数"<<endl;
        }

        virtual void show()   //这里要变成虚函数
        {
            cout<<"this is parent"<<endl;
        }

        virtual ~Parent()
        {
            cout<<"parent的析构函数"<<endl;
        }

};

class Child:public Parent      //1.继承
{
    public:
        Child()
        {
            cout<<"Child的构造函数"<<endl;
        }
        void show()
        {
            cout<<"this is child"<<endl;    //要有虚函数重写
        }
        virtual ~Child()
        {
            cout<<"Child的析构函数"<<endl;
        }
};

int main(int argc, char const *argv[])
{
    Parent *p1 = new Child;   //基类指针指向派生类对象
    p1->show();               //静态联编,编译器会根据p1的类型(Parent)调用Parent里面的show函数

    delete p1;
    p1 = NULL;

    return 0;
}

在这里插入图片描述
1.4 动态类型识别
新关键词：dynameic_cast
dynameic_cast：是C++中的新关键词
dynameic_cast：用于基类和派生类之间的转换
dynameic_cast：要求使用的目标类型是多态–》1.要求所在类至少有一个虚函数 2.用于指针转换时，转换失败返回NULL指针 3.用于引用转换，转换失败引发bad_cast异常

自定义类型：

#include <iostream>
using namespace std;

class Parent
{
    private:
        int a;
    
    public:
        enum{ID = 0};

        virtual void show()   //虚函数
        {
            cout<<"this is parent"<<endl;
        }
        virtual int GetId()
        {
            return ID;
        }
};

class Child:public Parent
{
    public:
        int array[102400];

        enum{ID = 1};
        void show()
        {
            cout<<"this is child"<<endl;
        }

        virtual int GetId()
        {
            return ID;
        }
};

void f(Parent *p)
{
    if(p->GetId() == Child::ID)
    {
        Child *c = (Child *)p;
        c->array[102400-1] = 100;
        cout<<"转换成功"<<endl;
    }
    else
    {
        cout<<"转换失败"<<endl;
    }
}

int main(int argc, char const *argv[])
{
    Parent *p1 = new Parent;   
    //Parent *p1 = new Child; 
    f(p1);

    delete p1;

    return 0;
}

在这里插入图片描述
1.5 使用dynameic_cast

#include <iostream>
using namespace std;

class Parent
{
    private:
        int a;
    
    public:
        virtual void show()   //虚函数
        {
            cout<<"this is parent"<<endl;
        }    
};

class Child:public Parent
{
    public:
        int array[102400];
        void show()
        {
            cout<<"this is child"<<endl;
        }
};

void f(Parent *p)
{
    Child *c = dynamic_cast<Child *>(p);
    if( c != NULL)
    {
        c->array[102400-1] = 100;
        cout<<"转换成功"<<endl;
    }
    else
    {
        cout<<"转换失败"<<endl;
    }
}

int main(int argc, char const *argv[])
{
    //Parent *p1 = new Parent;   
    Parent *p1 = new Child; 
    f(p1);

    delete p1;

    return 0;
}

在这里插入图片描述
typeid()函数
功能：用来获取一个表达式的类型信息
typeid的操作对象既可以是表达式也可以是数据类型，使用方法如下：
typeid(Data Type);
typeid(expression);

#include <iostream>
using namespace std;

class Parent
{
    private:
        int a;
    
    public:
        virtual void show()   //虚函数
        {
            cout<<"this is parent"<<endl;
        }    
};

class Child:public Parent
{
    public:
        int array[102400];
        void show()
        {
            cout<<"this is child"<<endl;
        }
};

void f(Parent *p)
{
    //Child *c = dynamic_cast<Child *>(p);
    if( typeid(*p) == typeid(Child))
    {
        Child *c = (Child *)p;
        c->array[102400-1] = 100;
        cout<<"转换成功"<<endl;
    }
    else
    {
        cout<<"转换失败"<<endl;
    }
}

int main(int argc, char const *argv[])
{
    //Parent *p1 = new Parent;   
    int a;
    char ch;
    Parent p1;
    Child c1;

    const type_info &pa = typeid(a);
    const type_info &pb = typeid(ch);
    const type_info &pc = typeid(p1);
    const type_info &pd = typeid(c1);

    cout<<pa.name()<<endl;
    cout<<pb.name()<<endl;
    cout<<pc.name()<<endl;
    cout<<pd.name()<<endl;

    Parent *p = new Child; 
    f(p);

    delete p;

    return 0;
}

在这里插入图片描述
1.6 纯虚函数
在C++中，可以讲函数声明为纯虚函数，语法格式：
virtual 返回值类型 函数名（函数参数） = 0；

二、运算符重载的概念
重载：就是给运算符赋予一个新的含义，使得同一个运算符有不同的功能。
重载的本质就是函数的重载

#include <iostream>

using namespace std;

class Complex
{
    friend Complex operator+(const Complex &c1, const Complex &c2);
    private:
        int m_a;   //实部
        int m_b;   //虚部
    
    public:
        Complex(int a, int b)
        {
            this->m_a = a;
            this->m_b = b;
        }

        void print()
        {
            cout<<m_a<<"+"<<m_b<<"i"<<endl;
        }

    /*
        Complex operator+(const Complex &c)
        {
            Complex t(0,0);
            t.m_a = c.m_a + c.m_a;
            t.m_b = c.m_b + c.m_b;

            return t;
        }
    */
};

Complex operator+(const Complex &c1, const Complex &c2)
{
    Complex t(0,0);
    t.m_a = c1.m_a + c2.m_a;
    t.m_b = c1.m_b + c2.m_b;

    return t;
}


int main(int argc, char const *argv[])
{
    Complex c1(1 , 2);
    Complex c2(2 , 3);
    c1.print();
    Complex t(0 , 0);

    //双目运算符，通常双目运算符重载用类的友元函数，但是有四个要用类的成员函数   =，（），[]，->
    t = c1 + c2;    //编译器会转成 t = operator+(c1，c2)
                    //类成员函数会变成 ---t = c1.operator(c2);

    t.print();

    return 0;
}

在这里插入图片描述
运算符重载的规则
1.不能重载的运算符：
1）作用域解析运算符 ::
2）条件运算符 ?:
3）直接成员访问运算符 .
4) 类成员指针引用的运算符 .*
5）sizeof运算符 sizeof

2.重载不能改变运算符的优先级和结合性
3.重载不能改变运算符的用法
4.运算符重载不能有默认参数，否则会改变运算符的操作数
5.运算符重载函数可以作为类的成员函数也可以作为全局函数

运算符重载步骤：
1）写出重载函数名称，比如：operator+
2）根据操作数写函数的形参，如 operator+（int a, Complex &c）
3）根据使用场景写出函数的返回值，如：Complex operator+（int a, Complex &c）
4）完成函数体

2.4 重载输出运算符

#include <iostream>

using namespace std;

class Complex
{
    friend ostream& operator<<(ostream &out, Complex &c);
    friend Complex operator+(const Complex &c1, const Complex &c2);
    private:
        int m_a;   //实部
        int m_b;   //虚部
    
    public:
        Complex(int a, int b)
        {
            this->m_a = a;
            this->m_b = b;
        }

        void print()
        {
            cout<<m_a<<"+"<<m_b<<"i"<<endl;
        }

    /*
        Complex operator+(const Complex &c)
        {
            Complex t(0,0);
            t.m_a = c.m_a + c.m_a;
            t.m_b = c.m_b + c.m_b;

            return t;
        }
    */
};

Complex operator+(const Complex &c1, const Complex &c2)
{
    Complex t(0,0);
    t.m_a = c1.m_a + c2.m_a;
    t.m_b = c1.m_b + c2.m_b;

    return t;
}

//输出运算符重载
ostream& operator<<(ostream &out, Complex &c)
{
    out<<c.m_a<<"+"<<c.m_b<<"i";
    return out;
}


int main(int argc, char const *argv[])
{
    Complex c1(1 , 2);
    Complex c2(2 , 3);
    c1.print();
    Complex t(0 , 0);

    //双目运算符，通常双目运算符重载用类的友元函数，但是有四个要用类的成员函数   =，（），[]，->
    t = c1 + c2;    //编译器会转成 t = operator+(c1，c2)
                    //类成员函数会变成 ---t = c1.operator(c2);

    cout<<t<< endl;
    //t.print();


    return 0;
}

2.5 单目运算符

#include <iostream>

using namespace std;

class Complex
{
    friend ostream& operator<<(ostream &out, Complex &c);
    friend Complex operator+(const Complex &c1, const Complex &c2);
    private:
        int m_a;   //实部
        int m_b;   //虚部
    
    public:
        Complex(int a, int b)
        {
            this->m_a = a;
            this->m_b = b;
        }

        void print()
        {
            cout<<m_a<<"+"<<m_b<<"i"<<endl;
        }

        Complex& operator++()   //前置++
        {
            this->m_a++;
            this->m_b++;

            return *this;   
        }

        Complex& operator++(int)   //后置++
        {
            Complex t = *this;
            this->m_a++;
            this->m_b++;

            return t;
        }
 
    /*
        Complex operator+(const Complex &c)
        {
            Complex t(0,0);
            t.m_a = c.m_a + c.m_a;
            t.m_b = c.m_b + c.m_b;

            return t;
        }
    */
};

Complex operator+(const Complex &c1, const Complex &c2)
{
    Complex t(0,0);
    t.m_a = c1.m_a + c2.m_a;
    t.m_b = c1.m_b + c2.m_b;

    return t;
}

//输出运算符重载
ostream& operator<<(ostream &out, Complex &c)
{
    out<<c.m_a<<"+"<<c.m_b<<"i";
    return out;
}


int main(int argc, char const *argv[])
{
    Complex c1(1 , 2);
    Complex c2(2 , 3);
    c1.print();
    Complex t(0 , 0);

    //双目运算符，通常双目运算符重载用类的友元函数，但是有四个要用类的成员函数   =，（），[]，->
    t = c1 + c2;    //编译器会转成 t = operator+(c1，c2)
                    //类成员函数会变成 ---t = c1.operator(c2);

    cout<<t<< endl;
    //t.print();

    t = ++c1;
    cout<<t<< endl;

    t = c1++;
    cout<<t<< endl;



    return 0;
}

在这里插入图片描述

冬雪如春
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
BJFU2023-C++程序设计-实验4-运算符重载
2301_76891302的博客
04-13 312
描述实现一个Singer类，通过以下测试：int main()if(s1>s2)elsereturn 0;输入输入包含两行，第一行为歌手s1的信息，第二行为歌手s2的信息，每位歌手的信息包括姓名（不包含空格）、性别、年龄 和 分数；姓名、性别、年龄和分数之间用空格分隔输出输出为三行，前两行分别是歌手s1和s2的信息，第三行根据s1和s2比较结果输出（s1和s2的比较结果和他们的分数的比较结果一致），具体参见主函数输入样例 1输出样例 1提示。
C++基础知识大全
weixin_49199646的博客
10-31 1万+
秋招基本尘埃落定了，打算总结一下C++学习路线的相关知识，今天是第一篇：C++基础知识总结。 面向对象的三大特性： 1、封装：把客观事物抽象为类，包含自己的属性和方法。 2、继承：使用现有类的所有功能，在无需重新编写原有类的情况下对类的功能进行拓展。被继承的类成为父类或基类，继承的类成为子类或派生类。 3、多态：一种形式，多种状态，分为静态多态和动态多态。静态多态指编译时多态，如函数重载、模板；动态多态指运行时多态，特指virtual虚函数机制形成的多态。 类的访问权限：private、protected
C++回顾（十）—— 多态
qq_50615776的博客
03-07 324
这里简单介绍了一下多态，就是指相同的代码完成不同的任务。多态成立的话要有继承、虚函数的重写、和父类指针指向子类对象；也简单介绍了一下多态的原理实现，是通过虚函数表指针去那个表里查找函数的。最后就是虚析构函数了
C++ 继承中构造析构调用原则
年年年的博客
11-09 780
本文主要总结一下继承关系下的构造析构调用原则： 子类对象在创建时会首先调用父类的构造函数 父类构造函数执行结束后，执行子类的构造函数 当父类的构造函数有参数时，需要在子类的初始化列表中显示调用 析构函数调用的先后顺序与构造函数相反 #include<iostream> using namespace std; class Parent { public: Parent() { cout << "Parent().." << endl; a = 0; }
C++基础知识点总结
深度学习 || 神经网络
02-07 1万+
自学c++过程中遇到的一些需要记忆的知识点,参考小甲鱼C++教程。
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 25万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++重点基础知识汇总大全
GeniusAng的博客
05-28 1180
C++重点基础知识汇总大全
C++——基础知识入门
ljinshuo的博客
10-31 8701
1.初识C++ 1.1第一个C++程序 创建新项目，选择创建C++的空项目： 选择项目名称与位置： 在源文件中添加C++文件： # include <iostream> using namespace std; int main() { cout << "hello world" << endl; system("pause"); return 0; } 1.2注释 # include <iostream> using namespac
C++入门基础知识总结（2022整理）
weixin_55305220的博客
03-23 2万+
一、C++入门基础知识之什么是C++? 1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。 PDF版、C++资料教程、C++电子书籍获取 关注微信公众号：“ C和C加加 ” 回复关键字：“ C++ ”即可领取 二、C++入门基础..
C++基础知识4：unordered_set
qq_35702489的博客
12-11 3187
简单的介绍一下unordered在不同地方使用的作用，在全局，在函数，在类里面的使用，以及相关应用举例
C++基础知识总结
08-30
C++基础知识总结 C++是一种功能强大且复杂的编程语言，具有许多基础知识点需要掌握。以下是C++基础知识总结，涵盖了new和malloc的区别、C++运算符、取地址运算符、引用、const变量等。 一、新和malloc的区别 在...
C++基础知识.docx
10-17
2019年秋招面试自己吐血整理的资料 C++： 共计32页，30282字 总结的知识点基本涵盖了计算机专业相关面试的基础理论知识，足以应对一般的计算机类工作面试，并且已经按照知识模块进行了目录索引，方便查询
c++基础知识2.jpg
03-30
适合初学者的c++基础知识
c++基础知识1.jpg
03-30
适合c++初学者，非常详细
C++基础知识.md
01-15
这是一篇C++基础知识，本文讲述了C++的基本数据类型、类型的取值范围，输入输出，变量和常量，输入输出格式控制等
新型开发语言的试用感受-仓颉语言发布之际
opendba的专栏
07-03 1338
Zig、Odin、Mojo、codon、carbon、nim等语言的使用感受
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 628
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
c++习题08-计算星期几
码到成龚的博客
07-03 595
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
Android 开发中 C++ 和Java 日志调试
最新发布
小羊子的技术专栏
07-04 914
Android 开发中 C++ 和Java 日志调试方法小结
C++基础知识.pdf
11-04
C++基础知识.pdf C++是一种功能强大且灵活的程序设计语言，广泛应用于大学生竞赛和中学生竞赛中。本文旨在为初学者提供一个窗口，通过例题了解什么是ACM，帮助刚入门的读者。 一、C++基础知识 1.1 "Hello,world!...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值