C++| |多态

最新推荐文章于 2024-03-14 09:14:32 发布
最新推荐文章于 2024-03-14 09:14:32 发布
阅读量436 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40399012/article/details/86489857
版权

多态

1. 概念

对于不同的对象，去完成同一个行为的时候产生不同的状态

 

2. 定义和实现

2.1 定义

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价

在继承中要构成多态还有两个条件：

  • 调用函数的对象必须是指针或者引用

  • 被调用的函数必须是虚函数，且完成了虚函数的重写

什么是虚函数？

  • 虚函数：就是在类的成员函数的前面加virtual关键字

例：

class Person
{
public：
    virtual void BuyTicket()
    {}
}

什么是虚函数的重写？

  • 虚函数的重写：派生类中有一个跟基类的完全相同虚函数，我们就称子类的虚函数重写了基类的虚函数，完全相同是指：函数名，参数，返回值都相同。虚函数的重写也叫作虚函数的覆盖

例：

#include <iostream>
​
class Person
{
public:
    virtual void BuyTicket()
    {
        std::cout << "买票全价" << std::endl;
    }
};
​
class Student : public Person
{
public:
    virtual void BuyTicket()
    {
        std::cout << "买票半价" << std::endl;
    }
};
​
​
void Func(Person& p)
{
    p.BuyTicket();
}
​
int main()
{
    Person ps;
    Student st;
    Func(ps);
    Func(st);
    return 0;
}

虚函数重写的例外：协变

协变：重写的虚函数的返回值可以不同，但是必须分别是基类指针和派生类指针或者基类引用和派生类引用。

例：

#include <iostream>
​
class A
{};
​
class B : public A
{};
​
class Person
{
public:
    virtual A* f()
    {
        std::cout << "In Person!" << std::endl;
        return new A;
    }
};
​
class Student : public Person
{
public:
    virtual B* f()
    {
        std::cout << "In Student!" << std::endl;
        return new B;
    }
};
​
void Func(Person& p)
{
    p.f();
}
​
int main()
{
    Person p;
    Student stu;
    Func(p);
    Func(stu);
    return 0;
}

不规范的重写行为

  • 在派生类中重写的成员函数可以不加virtual关键字，也是构成重写的。因为继承后基类的虚函数被继承下来在派生类中仍然保持虚函数属性。

例：

class Person
{
public:
    virtual void BuyTicket()
    {
        std::cout << "买票全价" << std::endl;
    }
};
​
class Student : public Person
{
public:
    void BuyTicket()//没有添加virtual关键字，但是也可以进行重写
    {
        std::cout << "买票半价" << std::endl;
    }
};
​
​
void Func(Person& p)
{
    p.BuyTicket();
}
​
int main()
{
    Person ps;
    Student st;
    Func(ps);
    Func(st);
    return 0;
}

析构函数的重写问题

基类中的析构函数如果是虚函数，那么派生类的析构函数就重写了基类的析构函数。这里他们的函数名不相同，看起来违背了重写的规则，其实不然这里可以理解为编译器对析构函数的名称做了特殊的处理，编译之后析构函数的名称统一处理成destructor，这也说明基类的析构函数最好写成虚函数

如果不写成虚函数就会造成析构不完全。对于析构派生类对象的时候，不写成虚函数的时候，析构派生类对象就只会清理派生类自己的资源而不会清理继承来的基类的资源

例：

class Person {
public:
    virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
    virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
    Person* p1 = new Person();
    Person* p2 = new Student();
    delete p1;
    delete p2;
    return 0;
}

接口继承和实现继承

  • 普通函数的继承是一种实现继承，派生类继承了基类函数，继承是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数

 

2.2 重载，覆盖（重写），隐藏（重定义）

重载：

  • 两个函数在同一作用域

  • 函数名，参数相同

重写：

  • 两个函数在不同作用域

  • 函数名，参数，返回值都相同（协变）

  • 两个函数必须是虚函数

重定义：

  • 两个函数在不同作用域

  • 函数名相同

  • 两个基类和派生类的同名函数不构成重写就是重定义

 

3. 抽象类

在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫作接口类），抽象类不能实例化出对象。派生类继承之后也不能实例化出对象，只有重写虚函数，派生类才能实例化出对象。存续函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承

例：

class A
{
public:
    virtual void Show() = 0;//纯虚函数
};
​
class B : public A
{
public:
    virtual void Show() override
    {
        std::cout << "In Class B" << std::endl;
    }
};
​
class C : public A
{
public:
    virtual void Show() override//完成虚函数的强制重写
    {
        std::cout << "In Class C" << std::endl;
    }
};
​
int main()
{
    A* a1 = new B();
    A* a2 = new C();
    a1->Show();
    a2->Show();
}

 

 

4. C++11 override和final

C++提供override和final来修饰虚函数

实际当中多使用纯虚函数+override的方式来强制重写虚函数，因为虚函数的意义就是实现多态，如果没有重写，虚函数就没有意义

final修饰基类的虚函数不能被派生类重写

例：

class Person
{
public:
    virtual void Say() = 0;//纯虚函数
    virtual void View() final
    {
        std::cout << "View You!" << std::endl;
    }
};
​
class Student : public Person
{
    virtual void Say() override
    {
        std::cout << "In Student" << std::endl;
    }
​
};
​
int main()
{
    Person* p = new Student();
    p->Say();
    p->View();
    return 0;
}

final的使用：对于final修饰的虚函数虽说不能被其派生类所重写，但是在基类当中自己一定要实现，否则继承下去还是一个虚函数并且没有完成重写就会导致无法实例化出对象

 

5. 多态的原理

5.1 虚函数表

class Base
{
public:
    virtual void Show()
    {
        std::cout << "haha" << std::endl;
    }
​
private:
    int _b;
};
​
int main()
{
    Base a;
    return 0;
}

结果是8个字节，除了_b成员外，还多了一个 _vfptr放在对象前面（有些平台可能放到对象的后面，这个和平台有关），对象中的这个指针我们叫做虚函数表指针。

一般是将虚函数表的指针放到对象实例中最前面的位置：这是为了保证取到的虚函数表有最高的性能——如果有多层继承或是多重继承的情况下。这意味着我们可以通过对象实例得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数

一个含有虚函数的类都至少有一个虚函数表指针，因为虚函数的地址要放到虚函数表中，虚函数表也简称虚表

插图：

虚函数表指针监视

对于虚函数表的指针的查看可以看到，虚函数表里面存放的函数指针的类型是void(*)()

虚函数存放在虚函数表中是一个无参无返回值类型的函数指针

对于上述代码增加一个派生类去继承BaseDerive中重写Func1Base在增加一个虚函数Func2和一个普通函数Func3

class Base
{
public:
    virtual void Func1()
    {
        std::cout << "haha" << std::endl;
    }
​
    virtual void Func2()
    {
        std::cout << "he" << std::endl;
    }
​
    void Func3()
    {
        std::cout << "ha" << std::endl;
    }
​
private:
    int _b;
};
​
class Derive : public Base
{
public:
    virtual void Func1()
    {
        std::cout << "hehe" << std::endl;
    }
};
​
int main()
{
    Base a;
    Derive d;
    return 0;
}

插图：虚函数表继承之后内存

 

通过观测和测试，我们发现了几点问题：

  1. 派生类对象d中也有一个虚表指针，d由两部分构成，一部分是父类继承下来的成员，另一部分是自己的成员

  2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的徐表中存的是重写的Derive::Func1，所以虚函数重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法

  3. 另外Func2继承下来后是虚函数，所以放到了虚表，Func3业绩呈下来了，但是不是虚函数，所以不会放到虚表中

  4. 虚函数表本质是一个存虚函数表指针的指针数组，这个数组最后面放了一个nullptr

总结一下派生类虚表的生成：

  • 先将基类中的虚表内容拷贝一份到派生类虚表中

  • 如果派生类重写了基类中的某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数

  • 派生类自己新增加的虚函数按其在派生类中的声明顺序增加到平派生类虚表的最后

【问题】

虚函数存在哪的，虚表存在哪的？

  • 虚函数和普通函数一样都是存在代码段的，只是它的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。虚表存在于数据段

 

5.2 多态的原理

class Person {
public:
    virtual void BuyTicket() 
    { 
        cout << "买票-全价" << endl; 
    }
};
​
class Student : public Person {
public:
    virtual void BuyTicket() 
    { 
        cout << "买票-半价" << endl; 
    }
};
​
void Func(Person& p)
{
    p.BuyTicket();
}
int main()
{
    Person Mike;
    Func(Mike);
    Student Johnson;
    Func(Johnson);
    return 0;
}

插图：多态原理

 

对于Func函数传入Person调用的是Person::BuyTicket，传入Student调用的是Student::BuyTicket

p是指向Mike对象时，p->BuyTcket在Mike的虚表中找到虚函数是Person::BuyTicket

p是指向John对象时，p->BuyTicket在John的虚表中找到虚函数的是Student::BuyTicket

这样就实现了不同对象去完成同一行为时，展现出不同的形态

思考：为什么完成有两个条件，一个是虚函数覆盖，还有一个是对象的指针或者引用去调用虚函数

  • 对于要虚函数覆盖就是为了对于基类和派生类对于同一个函数可以做出不同的行为

  • 要拿指针或者引用去调用是为了可以对于不同的对象找到不同的虚函数表，如果不是使用指针或者引用去调用函数的话，就会变成一个传值调用，就会发生切片，就会都调用基类的虚函数表中的虚函数

满足多态的函数调用不是在编译是确定好的，是运行起来以后到对象中去找的。不满足多态的函数调用是在编译时就确认好的

 

5.3 动态绑定与静态绑定

  1. 静态绑定又称为前期绑定（早绑定）在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载

  2. 动态绑定又称后期绑定（晚绑定），在程序运行期间，根据具体拿到的类型确定确定程序的具体行为，调用具体的函数，也成为动态多态。比如：动态

 

6. 单继承和多继承关系的虚函数表

派生类对象的虚表模型

 

6.1 单继承中的虚函数表

class Base {
public:
    virtual void func1() 
    { 
        cout << "Base::func1" << endl; 
    }
    
    virtual void func2() 
    { 
        cout << "Base::func2" << endl; 
    }
private:
    int a;
};
​
class Derive :public Base {
public:
    virtual void func1() 
    { 
        cout << "Derive::func1" << endl; 
    }
    
    virtual void func3() 
    { 
        cout << "Derive::func3" << endl; 
    }
    
    virtual void func4() 
    { 
        cout << "Derive::func4" << endl; 
    }
    
private:
    int b;
};
​
int main()
{
    Derive d;
    return 0;
}

插图：单继承虚函数表

观察监视窗口我们可以发现看不到func3和func4。那么我们如何来使用代码显示出虚表中的函数呢？

typedef void(* VFPTR) ();
​
class Base {
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
private:
    int a;
};
class Derive :public Base {
public:
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func3" << endl; }
    virtual void func4() { cout << "Derive::func4" << endl; }
private:
    int b;
};
​
void PrintVFPTR(VFPTR* vf)
{
    std::cout << " 虚表地址>" << vf << std::endl;
    for (int i = 0; vf[i] != nullptr; ++i)
    {
        printf(" 第%d个虚函数地址 :0X%x,->", i, vf[i]);
        VFPTR f = vf[i];
        f();
    }
    std::cout << endl;
}
​
int main()
{
    Base a;
    Derive d;
​
    VFPTR* vf = (VFPTR*)(*(int*)&a);
    PrintVFPTR(vf);
​
    VFPTR* vf1 = (VFPTR*)(*(int*)&d);
    PrintVFPTR(vf1);
    return 0;
}

插图：单继承的内存存储

 

思路：取出b，d对象的头4个字节，就是虚标的指针

  1. 先取b的地址，强制转化为一个int*的指针

  2. 在解引用取值，就去到了b对象头4四个字节的值，这个值就是指向虚表的指针

  3. 再强转为VFPTR*，因为虚表就是一个存VFPTR类型（虚函数指针类型）的数组

  4. 虚函数指针传递给PrintVFPTR进行打印虚表

  5. 注意：有的时候打印虚表的代码经常崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要清理解决方案就好了

 

6.2 多继承中的虚函数表

typedef void (*VFPTR) ();
class A
{
public:
    virtual void func1()
    {
        std::cout << "A::func1" << std::endl;
    }
​
    virtual void func2()
    {
        std::cout << "A::func2" << std::endl;
    }
};
​
class B
{
public:
    virtual void func1()
    {
        std::cout << "B::func1" << std::endl;
    }
​
    virtual void func2()
    {
        std::cout << "B::func2" << std::endl;
    }
};
​
class C : public A ,public B
{
public:
    virtual void func1()
    {
        std::cout << "C::func1" << std::endl;
    }
​
    virtual void func3()
    {
        std::cout << "C::func3" << std::endl;
    }
};
​
void PrintVFPTR(VFPTR* vftable)
{
    std::cout << "虚函数地址:>" << vftable << std::endl;
​
    for (int i = 0; vftable[i] != nullptr; i++)
    {
        printf("第%d个虚函数表地址:0X%x,->", i, vftable[i]);
        VFPTR f = vftable[i];
        f();
    }
    std::cout << std::endl;
}
​
int main()
{
    C c;
    VFPTR* vf = (VFPTR*)(*(int*)&c);
    PrintVFPTR(vf);
​
    VFPTR* vf1 = (VFPTR*)(*(int*)((char*)&c + sizeof(A)));
    PrintVFPTR(vf1);
    return 0;
}

插图：多继承的内存存储

多继承的派生类未重写的虚函数放在第一个继承基类部分的虚函数表中

 

6.3 安全性

对于C++的存在虚函数表的安全性

通过父类类型的指针访问子类自己的虚函数

  • 我们知道，子类没有重写父类的虚函数是一件毫无意义的事情。因此多态也是要基于函数重写。虽然对于上述类A中的虚表有C的虚函数，但我们根本不可能使用下面的语句调用子类的私有的虚函数

  • A* a = new C;
a->func3();//编译出错

     

  • 任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会别编译器视为非法。但在运行时，我们可以通过指针的方式访问虚函数来达到违反C++语义的行为

访问non-public的父类的虚函数

  • 另外，如果父类的虚函数是private或者是protected的，但这些非public的虚函数同样会存在与虚函数表中，所以我们可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的

例：

class Base
{
private:
    virtual void f()
    {
        std::cout << "Base::f" << std::endl;
    }
};
​
class Derive : public Base
{
};
​
typedef void(*VFPTR)();
​
int main()
{
    Derive d;
    VFPTR vf = (VFPTR)*(int *)(*(int*)&d);
    vf();
    return 0;
}

 

 

6.4 多重继承的虚函数表访问

class Base1
{
public:
    virtual void func1()
    {
        std::cout << "Base1::func1" << std::endl;
    }
    virtual void func2()
    {
        std::cout << "Base1::func1" << std::endl;
    }
    virtual void func3()
    {
        std::cout << "Base1::func1" << std::endl;
    }
};
​
​
class Base2
{
public:
    virtual void func1()
    {
        std::cout << "Base2::func1" << std::endl;
    }
    virtual void func2()
    {
        std::cout << "Base2::func2" << std::endl;
    }
    virtual void func3()
    {
        std::cout << "Base2::func3" << std::endl;
    }
};
​
class Base3
{
public:
    virtual void func1()
    {
        std::cout << "Base3::func1" << std::endl;
    }
    virtual void func2()
    {
        std::cout << "Base3::func2" << std::endl;
    }
    virtual void func3()
    {
        std::cout << "Base3::func3" << std::endl;
    }
};
​
​
class Derive : public Base1, public Base2, public Base3
{
public:
    virtual void func1()
    {
        std::cout << "Derive::func1" << std::endl;
    }
​
    virtual void func4()
    {
        std::cout << "Derive::func4" << std::endl;
    }
};
​
typedef void(*VFPTR)();
​
int main()
{
    VFPTR pFun = nullptr;
    Derive d;
    int** vTable = (int**)&d;
​
    //Base1 vtable 
    //pFun = (Fun)*((int*)(*(int*)((int*)&d+0)+0))
    pFun = (VFPTR)vTable[0][0];
    pFun();
​
    //pFun = (Fun)*((int*)(*(int*)((int*)&d+0)+1))
    pFun = (VFPTR)vTable[0][1];
    pFun();
​
    //pFun = (Fun)*((int*)(*(int*)((int*)&d+0)+2))
    pFun = (VFPTR)vTable[0][2];
    pFun();
​
    //pFun = (Fun)*((int*)(*(int*)((int*)&d+0)+3))
    pFun = (VFPTR)vTable[0][3];
    pFun();
​
    //Base2 vtable 
    //pFun = (Fun)*(int*)(*(int*)((int*)&b + 1)+0);
    pFun = (VFPTR)vTable[1][0];
    pFun();
​
    //pFun = (Fun)*(int*)(*(int*)((int*)&b + 1)+0);
    pFun = (VFPTR)vTable[1][1];
    pFun();
​
    //pFun = (Fun)*(int*)(*(int*)((int*)&b + 1)+0);
    pFun = (VFPTR)vTable[1][2];
    pFun();
​
    //pFun = (Fun)*(int*)(*(int*)((int*)&b + 1)+0);
    //pFun = (VFPTR)vTable[1][3];
    //pFun();
​
    //Base3 vtable 
    //pFun = (Fun)*(int*)(*(int*)((int*)&b + 2)+0);
    pFun = (VFPTR)vTable[2][0];
    pFun();
​
    //pFun = (Fun)*(int*)(*(int*)((int*)&b + 2)+0);
    pFun = (VFPTR)vTable[2][1];
    pFun();
​
    //pFun = (Fun)*(int*)(*(int*)((int*)&b + 2)+0);
    pFun = (VFPTR)vTable[2][2];
    pFun();
​
    //pFun = (Fun)*(int*)(*(int*)((int*)&b + 2)+0);
    //pFun = (VFPTR)vTable[2][3];
    //pFun();
    return 0;
}

 

 

6.5 菱形继承和菱形虚拟继承

实际中我们不建议设计出菱形继承和菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型访问基类成员有一定的性能损耗

查看链接：

https://coolshell.cn/articles/12165.html

https://coolshell.cn/articles/12176.html

7. 多态常见的面试问题

  1. 什么是多态？

  2. 什么是重载，重写（覆盖），重定义（隐藏）？

  3. 多态的实现原理？

  4. inline函数可以是虚函数吗？

    • 不能因为inline函数没有地址，无法把地址放到虚函数表中

  5. 静态函数可以是虚函数吗？

    • 不能，因为静态函数没有this指针，使用类型::成员函数的调用方式无法放进虚函数表

  6. 构造函数可以是虚函数吗？

    • 不能，因为对象中的虚函数表是在构造函数初始化列表阶段才初始化的

  7. 析构函数可以是虚函数吗？

    • 可以，并且把基类的析构函数定义为虚函数。这样才可以析构正确实现多态

  8. 对象访问普通函数块还是虚函数更快？

    • 普通对象：一样快

    • 指针对象或者是引用对象：调用普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找

  9. 虚函数是在什么阶段生成的，存在哪的？

    • 虚函数是在编译阶段就生成的，一般情况下存在静态区的

  10. C++菱形继承的问题？虚继承的原理？

    • 虚表

  11. 什么是抽象类？抽象类的作用？

    • 含有纯虚函数。抽象类强制重写虚函数，另外抽象类体现出接口继承关系

 

_YKitty
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++多态总结
08-30
c++多态总结，vptr总结，多态原理探究
C++中运算符&和&&、|和||的区别详细讲解
weixin_48306625的博客
09-18 7660
简介： &&是逻辑与运算符，||是逻辑或运算符，都是逻辑运算符，两边只能是bool类型 &与| 既可以进行逻辑运算，又可以进行位运算，两边既可以是bool类型，又可以是数值类型 区别： if (A && B) 如果 A 为 false ，整个表达式就为 false，不再计算 B 的值了。 if (A & B) 如果 A 为 false ，整个表达式就为 false，但还要计算 B 的值。 if (A && B++) 如果A 为 false，&a
C++ |和|| ,&和&&等字符常用运算
u013083044的博客
05-21 1710
：逻辑非运算符的作用是反转其后面的表达式的值，即非0变成1，0变成1。1.3 按位异或(^)：如果相应的两个二进制位值不同，则该位的结果为1，否则为0。2.2 逻辑或(||)：当两个操作数至少有一个为真(非零)时，结果为真，否则为假。1.1 按位与(&)：如果相应的两个二进制位都为1，则该位的结果为1，否则为0。1.2 按位或(|)：如果相应的两个二进制位都为0，则该位的结果为0，否则为1。2.1 逻辑与(&&)：当两个操作数都为真(非零)时，结果为真，否则为假。
C/C++ 知识点：| 与 || 的区别
最新发布
个人技术博客
03-14 682
虽然和||在某些情况下可能看起来行为相似，但它们是两种不同的运算符，用于不同的目的。理解它们之间的区别对于编写正确的C++代码至关重要。按位或运算符用于位操作，而逻辑或运算符||用于逻辑判断。在使用这些运算符时，始终要注意上下文和预期的行为，以确保代码的正确性和效率。
C++ 中 | 和||
Akalaka的博客
08-25 3631
| :按位或运算符，转百度百科 || :逻辑或运算符，转百度百科
C++ || 复数类
weixin_63378697的博客
04-14 1297
实现-加-减-乘运算符重载运算符重载功能，并实现返回值为复数类。实现-加-减-乘运算符重载运算符重载功能，并实现返回值为复数类。复数类含两个参数的构造函数，一个为实部，一个为虚部。复数类含两个参数的构造函数，一个为实部，一个为虚部。复数类含两个参数的构造函数，一个为实部，一个为虚部。复数类含两个参数的构造函数，一个为实部，一个为虚部。复数类含两个参数的构造函数，一个为实部，一个为虚部。复数类含两个参数的构造函数，一个为实部，一个为虚部。复数类含两个参数的构造函数，一个为实部，一个为虚部。
C++多态Demo
05-01
长方形和三角形均继承于形状，拥有高和宽，分别求面积
C++ 多态的游戏例程
01-20
1）头文件 game.h #ifndef GAME_H #define GAME_H // base class class CCreature { protected: int m_nLifePower， m_nPower; public: virtual void Attack(CCreature *pCreature){} virtual void Hurted...
c++多态解析1
08-08
2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数 3.静态成员函数不能是虚函数,因为静态成员函数的特点
C++多态解释1
08-08
2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数 3.静态成员函数不能是虚函数,因为静态成员函数的特点
C的|、||、&、&&、异或、~、！运算
老衣的专栏
05-14 9342
位运算    位运算的运算分量只能是整型或字符型数据，位运算把运算对象看作是由二进位组成的位串信息，按位完成指定的运算，得到位串信息的结果。位运算符有：    &(按位与)、|(按位或)、^(按位异或)、~ (按位取反)。    其中，按位取反运算符是单目运算符，其余均为双目运算符。    位运算符的优先级从高到低，依次为~、&、^、|，    其中~的结合方向自右至左，且优先级高于算术运算符，其余运算符的结合方向都是自左至右，且优先级低于关系运算符。   (1)按位与运算符(&)    按位与运算将两个运
C++中逻辑运算符（&&，||）与位运算符（&，|）的使用
qq_40762280的博客
08-11 5800
逻辑运算符（&&，||）与位运算符（&，|）之间进行区分以及常见使用场景
C++中或运算符（||）执行的逻辑及顺序
ac不知深的博客
09-16 3319
当使用或运算符时或运算符左边为True，则不进行右边的判断。只要有一个为True，则整体为True以此类推，多个或运算符依然适用。
C++ 运算符
weixin_60461563的博客
01-03 4439
C++ 运算符
C/C++关于逻辑运算符“&&”和“||”的优先级问题及实验
m0_51444969的博客
10-30 4921
关于逻辑运算符“&&”和“||”的优先级问题及实验 目录： 1、前言； 2、实验代码及结果； 3、总结。 1、前言 在许多相关教材中，对于逻辑运算符“&&”和“||”的优先级问题，大都只有这样一句简单的描述：“逻辑运算符‘&&’的优先级高于逻辑运算符‘||’”。而在实际应用中我们会发现， ...
C++中运算符 &和&&、|和|| 的区别
在努力！
08-10 8万+
简介：&&是逻辑与运算符，||是逻辑或运算符，都是逻辑运算符，两边只能是bool类型 &与| 既可以进行逻辑运算，又可以进行位运算，两边既可以是bool类型，又可以是数值类型区别：if (A && B) 如果 A 为 false ，整个表达式就为 false，不再计算 B 的值了。 if (A & B) 如果 A 为 false ，整个表达式就为 false，但还要计算 B 的值。 if
C语言中&&,||,&,| 的区别
热门推荐
Yan_Programer 的专栏
08-10 10万+
&&：逻辑与，前后条件同时满足表达式为真 ||：逻辑或，前后条件只要有一个满足表达式为真 &：按位与 |：按位或 &&和||是逻辑运算，&与|是位运算 假如a = 0xaa ,b = 0x55 a&&b = true ,在计算机中true以非0值表示，不同的编译器true值也不一样，一般为1 a||b = true, a&b = 0; 值唯一 a|b = 0xff; 值唯一 “&&”跟“|”
C++ - 逻辑操作符（&& ， || ）应该注意的事
weixin_49303682的博客
08-11 428
1.逻辑运算符的结果 最终结果只能是true或者false。 逻辑表达式不用完全计算就能确定最终值（重点理解这句话）。 代码示例： #include <iostream> #include <string> using namespace std; int func(int i) { cout << "int func(int i) : i = " << i << endl; return i; }
c++ 多态
05-25
C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。 C++中的多态性有两种：静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用，也称为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值