【C++】继承

已于 2025-03-28 10:57:40 修改
阅读量749 收藏 22
点赞数 16
分类专栏： C++ 文章标签： c++ 算法 linux
于 2025-03-27 10:56:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Sakura_ding/article/details/146551507
版权

1. 继承的概念及定义

1.1 继承的概念

继承（inheritance）机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法（成员函数）和属性（成员变量），这样产生新的类，称派生类。

继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复用，继承是类设计层次的复用。

下面我们看到没有继承之前我们设计了两个类Student和Teacher，Student和Teacher都有姓名、地址、电话、年龄等成员变量，都有identity身份认证的成员函数，设计到两个类里面就是冗余的。当然他们也有一些不同的成员变量和函数，比如老师独有成员变量是职称，学生的独有成员变量是学号；学生的独有成员函数是学习，老师的独有成员函数是授课。

class Student
{
public:
    // 进入校园/图书馆/实验室刷二维码等身份认证
    void identity()
    {
    }
    //...
    // 学习
    void study()
    {
    }
    //...
protected:
    string _name = "peter"; // 姓名
    string _address; // 地址
    string _tel; // 电话
    int _age = 18; // 年龄

    int _stuid; // 学号
};

class Teacher
{
public:
    // 进入校园/图书馆/实验室刷二维码等身份认证
    void identity()
    {
    }
    //...
    // 授课
    void teaching()
    {
    }
    //...
protected:
    string _name = "张三"; // 姓名
    int _age = 18; // 年龄
    string _address; // 地址
    string _tel; // 电话

    string _title; // 职称
};

int main()
{
    return 0;
}

下面我们公共的成员都放到Person类中，Student和teacher都继承Person，就可以复用这些成员，就不需要重复定义了，省去了很多麻烦。

class Person
{
public:
    // 进入校园/图书馆/实验室刷二维码等身份认证
    void identity()
    {
        cout << "void identity()" << _name << endl;
    }
protected:
    string _name = "张三"; // 姓名
    string _address; // 地址
    string _tel; // 电话
    int _age = 18; // 年龄
};

class Student : public Person
{
public:
    // 学习
    void study()
    {
    }
    //...
protected:
    int _stuid; // 学号
};

class Teacher : public Person
{
public:
    // 授课
    void teaching()
    {
    }
    //...
protected:
    string _title; // 职称
};

int main()
{
    Student s;
    Teacher t;

    s.identity();
    t.identity();

    return 0;
}

1.2 继承定义

1.2.1 定义格式

下面我们看到Person是基类，也称作父类。Student是派生类，也称作子类。（因为翻译的原因，所以既叫基类/派生类，也叫父类/子类）。

class Student :public Person
{
public:
    int _stuid; // 学号
    int _major; // 专业
};
继承方式访问限定符
public继承public访问
protected继承protected访问
private继承private访问
1.2.2 继承基类成员访问方式的变化
类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见
  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在派生类都是不可见。基类的其他成员在派生类的访问方式 == Min（成员在基类的访问限定符，继承方式），public > protected > private。
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
  5. 在实际运用中一般使用都是public继承，几乎很少使用protected/private继承，也不提倡使用protected/private继承，因为protected/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
// 实例演示三种继承关系下基类成员的各类型成员访问关系的变化
class Person
{
public:
    void Print()
    {
        cout << _name << endl;
    }
protected:
    string _name; // 姓名
private:
    int _age; // 年龄
};

//class Student : protected Person
//class Student : private Person
class Student : public Person
{
protected:
    int _stunum; // 学号
};

1.3 继承类模板

namespace bit
{
    //template<class T>
    //class vector
    //{};

    // stack和vector的关系，既符合is-a，也符合has-a
    template<class T>
    class stack : public std::vector<T>
    {
    public:
        void push(const T& x)
        {
            // 基类是类模板时，需要指定一下类域，
            // 否则编译报错：error C3861: “push_back”: 找不到标识符
            // 因为stack<int>实例化时，也实例化vector<int>了
            // 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
            vector<T>::push_back(x);
            //push_back(x);
        }

        void pop()
        {
            vector<T>::pop_back();
        }

        const T& top()
        {
            return vector<T>::back();
        }

        bool empty()
        {
            return vector<T>::empty();
        }
    };
}

int main()
{
    bit::stack<int> st;
    st.push(1);
    st.push(2);
    st.push(3);

    while (!st.empty())
    {
        cout << st.top() << " ";
        st.pop();
    }

    return 0;
}

2. 基类和派生类间的转换

public继承的派生类对象可以赋值给基类的指针 / 基类的引用。

这里有个形象的说法叫切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。

基类对象不能赋值给派生类对象。

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI（Run-Time Type Information）的dynamic_cast来进行识别后进行安全转换。

class Person
{
protected:
    string _name; // 姓名
    string _sex; // 性别
    int _age; // 年龄
};

class Student : public Person
{
public:
    int _No; // 学号
};

int main()
{
    Student sobj;
    // 1.派生类对象可以赋值给基类的指针/引用
    Person* pp = &sobj;
    Person& rp = sobj;
    // 派生类对象可以赋值给基类的对象是通过调用后面会讲解的基类的拷贝构造完成的
    Person pobj = sobj;

    // 2.基类对象不能赋值给派生类对象，这里会编译报错
    sobj = pobj;

    return 0;
}

3. 继承中的作用域

3.1 隐藏规则

  1. 在继承体系中基类和派生类都有独立的作用域。
  2. 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用基类::基类成员显示访问）。
  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员。
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected:
    string _name = "小李子"; // 姓名
    int _num = 111; // 身份证号
};

class Student : public Person
{
public:
    void Print()
    {
        cout << " 姓名:" << _name << endl;
        cout << " 身份证号:" << Person::_num << endl;
        cout << " 学号:" << _num << endl;
    }
protected:
    int _num = 999; // 学号
};

int main()
{
    Student s1;
    s1.Print();

    return 0;
};

3.2 考察继承作用域相关选择题

3.2.1 A和B类中的两个func构成什么关系()

A. 重载 B. 隐藏 C.没关系

3.2.2 下面程序的编译运行结果是什么()

A. 编译报错 B. 运行报错 C. 正常运行

class A
{
public:
    void fun()
    {
        cout << "func()" << endl;
    }
};

class B : public A
{
public:
    void fun(int i)
    {
        cout << "func(int i)" << i << endl;
    }
};

int main()
{
    B b;
    b.fun(10);
    b.fun();

    return 0;
};

4. 派生类的默认成员函数

4.1 4个常见默认成员函数

6个默认成员函数，默认的意思就是指我们不写，编译器会帮我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。需要注意的是派生类的operator=隐藏了基类的operator=，所以显示调用基类的operator=，需要指定基类作用域。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
  5. 派生类对象初始化先调用基类构造再调派生类构造。
  6. 派生类对象析构清理先调用派生类析构再调基类的析构。
  7. 因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系。
    在这里插入图片描述
class Person
{
public:
    Person(const char* name = "peter")
        : _name(name)
    {
        cout << "Person()" << endl;
    }

    Person(const Person& p)
        : _name(p._name)
    {
        cout << "Person(const Person& p)" << endl;
    }

    Person& operator=(const Person& p)
    {
        cout << "Person operator=(const Person& p)" << endl;
        if (this != &p)
        {
            _name = p._name;
        }
        return *this;
    }

    ~Person()
    {
        cout << "~Person()" << endl;
    }
protected:
    string _name; // 姓名
};

class Student : public Person
{
public:
    Student(const char* name, int num)
        : Person(name)
        , _num(num)
    {
        cout << "Student()" << endl;
    }

    Student(const Student& s)
        : Person(s)
        , _num(s._num)
    {
        cout << "Student(const Student& s)" << endl;
    }

    Student& operator=(const Student& s)
    {
        cout << "Student& operator= (const Student& s)" << endl;
        if (this != &s)
        {
            // 构成隐藏，所以需要显示调用
            Person::operator=(s);
            _num = s._num;
        }
        return *this;
    }

    ~Student()
    {
        cout << "~Student()" << endl;
    }
protected:
    int _num; // 学号
};

int main()
{
    Student s1("jack", 18);
    Student s2(s1);
    Student s3("rose", 17);
    s1 = s3;

    return 0;
}

4.2 实现一个不能被继承的类

方法1：基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。
方法2：C++11新增了一个final关键字，final修改基类，派生类就不能继承了。

// C++11的方法
class Base final
{
public:
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
private:
    // C++98的方法
    /*Base()
    {}*/
};

class Derive :public Base 
{
    void func4() { cout << "Derive::func4" << endl; }
protected:
    int b = 2;
};

int main()
{
    Base b;
    Derive d;

    return 0;
}

5. 继承与友元

友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员。

class Student;
class Person
{
public:
    friend void Display(const Person& p, const Student& s);
protected:
    string _name; // 姓名
};

class Student : public Person
{
protected:
    int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
    cout << p._name << endl;
    cout << s._stuNum << endl;
}

int main()
{
    Person p;
    Student s;
    // 编译报错：error C2248: “Student::_stuNum”: 无法访问 protected 成员
    // 解决方案：Display也变成Student 的友元即可
    Display(p, s);

    return 0;
}

6. 继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都只有一个static成员实例。

class Person
{
public:
    string _name;
    static int _count;
};

int Person::_count = 0;

class Student : public Person
{
protected:
    int _stuNum;
};

int main()
{
    Person p;
    Student s;

    // 这里的运行结果可以看到非静态成员_name的地址是不一样的
    // 说明派生类继承下来了，父派生类对象各有一份
    cout << &p._name << endl;
    cout << &s._name << endl;

    // 这里的运行结果可以看到静态成员_count的地址是一样的
    // 说明派生类和基类共用同一份静态成员
    cout << &p._count << endl;
    cout << &s._count << endl;

    // 公有的情况下，父派生类指定类域都可以访问静态成员
    cout << Person::_count << endl;
    cout << Student::_count << endl;

    return 0;
}

7. 多继承及其菱形继承问题

7.1 继承模型

单继承：一个派生类只有一个直接基类时称这个继承关系为单继承。

多继承：一个派生类有两个或以上直接基类时称这个继承关系为多继承。多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员在放到最后面。

菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。
在这里插入图片描述

class Person
{
public:
    string _name; // 姓名
};
class Student : public Person
{
protected:
    int _num; //学号
};
class Teacher : public Person
{
protected:
    int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
    string _majorCourse; // 主修课程
};
int main()
{
    // 编译报错:error C2385: 对“_name”的访问不明确
    Assistant a;
    a._name = "peter";
    // 需要显示指定访问哪个基类的成员可以解决二义性问题,但是数据冗余问题无法解决
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
    return 0;
}

7.2 虚继承

很多人说C++语法复杂，其实多继承就是一个体现。
有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有一些损失，所以最好不要设计出菱形继承。
多继承可以认为是C++的缺陷之一，后来的一些编程语言都没有多继承，如Java。

使用虚拟继承,可以解决菱形继承中的数据冗余和二义性

class Person
{
public:
    string _name; // 姓名
    /*int _tel;
    int _age;
    string _gender;
    string _address;*/
    //...
};
// 使用虚继承Person类
class Student : virtual public Person
{
protected:
    int _num; //学号
};
// 使用虚继承Person类
class Teacher : virtual public Person
{
protected:
    int _id; // 职工编号
};
// 教授助理
class Assistant : public Student, public Teacher
{
protected:
    string _majorCourse; // 主修课程
};
int main()
{
    // 使用虚继承,可以解决数据冗余和二义性
    Assistant a;
    a._name = "peter";
    return 0;
}

我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，无论是使用还是底层都会复杂很多。当然有多继承语法支持，就一定存在会设计出菱形继承，像Java是不支持多继承的，就避开了菱形继承。

class Person
{
public:
    Person(const char* name)
        :_name(name)
    {}
    string _name; // 姓名
};
class Student : virtual public Person
{
public:
    Student(const char* name, int num)
        :Person(name)
        ,_num(num)
    {}
protected:
    int _num; //学号
};
class Teacher : virtual public Person
{
public:
    Teacher(const char* name, int id)
        :Person(name)
        , _id(id)
    {}
protected:
    int _id; // 职工编号
};
// 不要去玩菱形继承
class Assistant : public Student, public Teacher
{
public:
    Assistant(const char* name1, const char* name2, const char* name3)
        :Person(name3)
        ,Student(name1, 1)
        ,Teacher(name2, 2)
    {}
protected:
    string _majorCourse; // 主修课程
};
int main()
{
    // 思考一下这里a对象中_name是"张三", "李四", "王五"中的哪一个?
    Assistant a("张三", "李四", "王五");
    return 0;
}

7.3 多继承中指针偏移问题？下面说法正确的是( )

A: p1p2p3
B: p1<p2<p3
C: p1==p3!=p2
D: p1!=p2!=p3

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main()
{
    Derive d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    Derive* p3 = &d;
    return 0;
}

7.4 IO库中的菱形虚拟继承

在这里插入图片描述

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits>
{};
template<class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits>
{};

8. 继承和组合

public继承是一种is - a的关系。也就是说每个派生类对象都是一个基类对象。

组合是一种has - a的关系。假设B组合了A，每个B对象中都有一个A对象。

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white - box reuse)。
术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对派生类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。
这种复用风格被称为黑箱复用(black - box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

优先使用组合，而不是继承。
实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is - a)那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承(is - a)也适合组合(has - a)，就用组合。

// Tire(轮胎)和Car(车)更符合has - a的关系
class Tire {
protected:
    string _brand = "Michelin"; // 品牌
    size_t _size = 17; // 尺寸
};
class Car {
protected:
    string _colour = "白色"; // 颜色
    string _num = "陕ABIT00"; // 车牌号
    // 轮胎
    Tire _t1; 
    Tire _t2;
    // 轮胎
    Tire _t3;
    // 轮胎
    Tire _t4;
};
class BMW : public Car {
public:
    void Drive() { cout << "好开 - 操控" << endl; }
};
// Car和BMW/Benz更符合is - a的关系
class Benz : public Car {
public:
    void Drive() { cout << "好坐 - 舒适" << endl; }
};
template<class T>
class vector
{};
// stack和vector的关系,既符合is - a,也符合has - a
template<class T>
class stack : public vector<T>
{};
template<class T>
class stack
{
public:
    vector<T> _v;
};
int main()
{
    return 0;
}
C++继承
Wzs040810的博客
02-03 1711
C++继承
C++继承详解
lim6ere的博客
03-29 1309
在本篇文章中我们将会学到有关继承方面的知识，其中C++中三大特性分别为：封装，继承多态。由此可见继承在学习中的重要性，接下来我们来一起看一下有关继承方面的知识吧！！！！😘 😚😘 😚😘 😚以上就是今天要讲的内容，本文仅仅详细介绍了C++继承的相关知识。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
C++ 继承
qq_50373827的博客
09-17 1247
多重继承中的二义性可以通过作用域解析运算符来解决。菱形继承问题可以通过虚继承来解决，确保派生类只继承基类的一份成员。在多重继承中，明确指定基类的方法或成员访问路径，能够有效避免继承中的模糊性问题。
C++ 继承详解
热门推荐
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++继承的使用
JayceSun的博客
04-17 2033
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
C++继承（带你一篇文章搞定C++的继承）
2301_80344616的博客
10-23 4717
我们前面讲了模板进阶的全部内容，今天我们要进入C++里面更深层的内容了，今天我们来讲解C++的继承继承的概念继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，以前我们接触的函数层次的复用，继承是类设计层次的复用。什么是复用呢？
C++继承之private继承
flysnow010的博客
04-10 1650
通过继承机制，可以利用已有的对象类型来定义新对象类型。所定义的新对象类型不仅仅拥有新定义的成员，而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类，又称为父类。由已存在的类派生出的新类称为派生类，又称为子类。 private继承 派生类中父类public成员变成private成员。
C++继承[万字详解]
weixin_47257473的博客
03-16 4304
本文非常详细介绍了C++中的继承，包括继承的定义，介绍，方式。以及继承后派生类构造函数和析构函数的调用顺序，继承中的切片等问题，继承后静态成员，友元关系的变化，以及多继承中的菱形继承和菱形虚拟继承，对继承的一些总结。继承和组合的介绍以及关系.
C++ 继承详解及实例代码
09-01
C++继承是面向对象编程中的一个核心概念，它允许创建一个新的类（子类或派生类）基于已存在的类（基类或父类）。通过继承，子类不仅可以获得基类的所有成员（包括数据成员和成员函数），还可以添加新的功能或者重写...
c++重点知识总结
Uk110的博客
06-06 880
1.基类private成员在派生类中无论以什么方式继承都是不可见的。这里的。
极限复习c++
2302_76213070的博客
06-05 2228
快速过一遍必背代码（类、多态、模板）和简答题答案，强化肌肉记忆！祝考试顺利，代码全 AC！
C/C++ 面试复习笔记（4）
apolloyhl的博客
06-06 925
内存颠簸是指系统在频繁地进行内存页的换入换出操作，导致大量的磁盘 I/O，系统性能急剧下降的现象。当系统的物理内存不足，而进程对内存的需求又不断变化时，就容易出现内存颠簸。例如，一个进程频繁地访问不同的内存页，而这些页在内存中频繁地被换出和换入。在 Linux 系统中，可以通过以下方法避免或解决内存颠簸问题：增加物理内存：如果物理内存不足是导致内存颠簸的主要原因，增加内存条可以直接提 高系统的可用内存，减少页交换操作。
加法c++
D_31415926的博客
06-06 386
给定 a 和 b 分别作为被加数和加数，而且限定 a 是 4 位数字，b 是 3 位数字，都是正整数。请你模拟以上加法过程进行输出。如果最后 a+b 的结果是 5 位数，为了保证对齐，需要在被加数和加数前面加空格。只需判断a+b的位数（注：四位数+三位数只可能是四位数或五位数，因为1000+100=1100，9999+999=10998），当a+b为四位数或五位数时输出特定的格式即可。输入两个正整数 a 和 b。
【题解】[UTPC2024] C.Card Deck
最新发布
scy923的博客
06-07 578
由于放入袋中后会进行补位，也就是说我们并不关心补进来的是哪一张真正的原始牌，当进行第。轮之后所有可能的袋子里牌所组成的集合的大小之和。考虑进行转化，只考虑前。，表示这张牌永远不会被放入袋子中，否则表示这张牌会在第。因此可以对每一张牌单独计算贡献。原题的模型是每一步可以选择顶部。，则这张牌出现在集合里的次数为。的牌都已经放入袋中，总共有。张牌，每张牌都有一个属性。张牌等价，所以最后的答案为。(可以为空）放在袋中，求。轮后袋子里的数，最后求。，下证明两个模型等价。
如何在c/c++中定义和使用宏
wydaicls的博客
06-07 386
本文介绍了C/C++中的宏定义和条件编译机制。宏定义分为对象式宏（如#define PI 3.1415926）和函数式宏（如#define MAX(a,b)），在预处理阶段进行文本替换，使用时需注意括号和多行定义的处理。条件编译通过#ifdef、#ifndef、#if等指令实现，其中#ifdef检查宏是否定义，#if使用表达式判断，并可用#elif和#else进行多分支控制。#undef可取消宏定义，#pragma once能防止头文件重复包含。这些预处理指令为代码提供了编译时的灵活控制能力。
使用 C/C++ 和 OpenCV 提取图像的感兴趣区域 (ROI)
m0_54069809的博客
06-07 849
本文介绍了使用C++和OpenCV库从图像中提取感兴趣区域(ROI)的方法。主要步骤包括：通过cv::imread()加载图像，用cv::Rect定义矩形ROI区域，利用cv::Mat的()运算符提取ROI，最后用cv::imshow()显示结果。文章提供了完整示例代码，并特别指出默认提取的是视图而非独立拷贝，若需独立操作可使用clone()或copyTo()方法创建深拷贝。该技术是计算机视觉中目标检测和图像分割等任务的基础。
C++继承详解与示例
"C++继承介绍，讲解了C++中的继承概念，包括public继承以及virtual、non-virtual和pure virtual成员函数的区别。通过示例代码展示了如何使用继承，并且验证了基类指针可以调用派生类对象的方法，但反之不行。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值