0721-----C++Primer听课笔记----------继承

最新推荐文章于 2025-08-22 12:09:46 发布
转载 最新推荐文章于 2025-08-22 12:09:46 发布 · 120 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/monicalee/p/3859102.html
文章标签：

#c/c++

本文详细介绍了C++中的继承机制，包括子类如何调用父类函数、子类函数重写与隐藏的区别、继承体系的特点及派生类对象与基类对象之间的转换等内容。此外，还探讨了静态绑定和动态绑定的概念，以及虚函数如何实现运行时多态。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. 通过子类对象来调用函数:

　　a)从父类继承而来的函数，可以正常使用；

　　b)子类自行添加的函数，可以正常使用；

　　c)子类编写和父类重名的函数，不管是否改变了参数，调用的都是子类的版本，如果需要调用父类的版本，需要显示指定父类名。

　　例1：

 

#include <iostream>
#include <string>
using namespace std;
/*
 * 派生类对象可以正常的调用从基类继承的函数
 */
class Person{
    public:
        Person(){}

        Person(int id,
               const string &name,
               int age)
            :id_(id),
             name_(name),
             age_(age){}

        ~Person(){}

        void set(int id, const string &name, int age){
            id_ = id;
            name_ = name;
            age_ = age;
        }

        void print() const{
            cout << id_ << " " << name_ << " " << age_ << endl;
        }

    private:
        int id_;
        string name_;
        int age_;
};
class Student : public Person{
    private:
        string school_;
};

int main(int argc, const char *argv[])
{
    Student s;
    s.set(123, "monica", 22);
    s.print();
    return 0;
}

例2：

#include <iostream>
#include <string>
using namespace std;
/*
 * 派生类对象可以正常调用 派生类自己编写的函数
 */
class Person{
    public:
        Person(){}

        Person(int id,
               const string &name,
               int age)
            :id_(id),
             name_(name),
             age_(age){}

        ~Person(){}


        void set(int id, const string &name, int age){
            id_ = id;
            name_ = name;
            age_ = age;
        }

        void print() const{
            cout << id_ << " " << name_ << " " << age_ << endl;
        }

    private:
        int id_;
        string name_;
        int age_;
};
class Student : public Person{
    public:
        // 这是派生类自己的函数
        void set_school(const string &school){
            school_= school;
        }

        void  print_school()const {
            cout << school_ << endl;
        }

    private:
        string school_;
};

int main(int argc, const char *argv[])
{
    Student s;
    s.set_school("hust");
    s.print_school();
    return 0;
}

例子3:

#include <iostream>
#include <string>
using namespace std;

class Person{
    public:
        Person(){}

        Person(int id,
               const string &name,
               int age)
            :id_(id),
             name_(name),
             age_(age){}

        ~Person(){}


        void set(int id, const string &name, int age){
            id_ = id;
            name_ = name;
            age_ = age;
        }

        void print() const{
            cout << id_ << " " << name_ << " " << age_ << endl;
        }

    protected: //protected 允许派生类成员访问
        int id_;
        string name_;
        int age_;
};
class Student : public Person{
    public:
        void set_school(const string &school){
            school_= school;
        }

        void  print_school()const {
            cout << school_ << endl;
        }

        void set(int id,
                 const string &name,
                 int age,
                 const string &school){
            id_ = id;
            name_ = name;
            age_ = age;
            school_ = school;
        }

        void print() const{
            cout << id_ << " " << name_ << " " << age_ << " " << school_ << endl;
        }



    private:
        string school_;
};

int main(int argc, const char *argv[])
{
    Student s;
    s.set(123, "monica", 22, "hust"); //这里调用的是派生类重写的函数
    s.print();
    s.Person::print(); //需要显示调用父类的函数
    return 0;
}

2. 子类重定义父类的函数，不管有没有改变参数， 当使用子类对象去调用这些函数的时候，调用的总是子类自定义的版本， 我们称为子类隐藏了父类的函数。

#include <iostream>
#include <string>
using namespace std;

class Person{
    public:
        Person(){}

        Person(int id,
               const string &name,
               int age)
            :id_(id),
             name_(name),
             age_(age){}

        ~Person(){}


        void set(int id, const string &name, int age){
            id_ = id;
            name_ = name;
            age_ = age;
        }

        void print() const{
            cout << id_ << " " << name_ << " " << age_ << endl;
        }

    protected: //protected 允许派生类成员访问
        int id_;
        string name_;
        int age_;
};
class Student : public Person{
    public:
        void set_school(const string &school){
            school_= school;
        }

        void  print_school()const {
            cout << school_ << endl;
        }

        void set(int id,
                 const string &name,
                 int age,
                 const string &school){
            id_ = id;
            name_ = name;
            age_ = age;
            school_ = school;
        }

        void print() const{
            cout << id_ << " " << name_ << " " << age_ << " " << school_ << endl;
        }



    private:
        string school_;
};

int main(int argc, const char *argv[])
{
    Student s;
    s.set(123, "monica", 22, "hust"); //这里调用的是派生类重写的函数
    s.print();

    Student s2;
    s2.Person::set(111, "jobs", 55); //要调用父类的函数必须显式的指出
    s2.Person::print();
    return 0;
}

3. 关于继承的一些要点：

　　3.1 面向对象的第二个特征是继承(inherit);

　　3.2 在类的继承体系中，父类扮演的是一种更加泛化、抽象的角色，子类扮演的则是一种更加具体的角色；

　　3.3 在继承中，父类还有的数据成员，子类全部都有(这里要注意：private 也被子类继承，只是无法直接访问)。

　　3.4 三种访问权限：

　　　　a）private 成员只能在类的内部被访问；

　　　　b）protected 成员在家族体系中是可见的；

　　　　c）public 成员在任意地方都是可见的。

4. 子类对象的构造

　　4.1 子类对象在构造的时候，会先生成一个父类的无名对象，所以子类对象内部包含一个父类对象，因此把子类对象赋值给父类对象是合法的，子类赋值的过程中，子类对象多余的部分被丢弃，这个赋值过程称为 对象的切除(这里要注意，C++类的对象， 只含有普通的数据成员，不包括函数)。

int main(int argc, const char *argv[])
{
    Student s;
    s.set(123, "monica", 22, "hust");
    s.print();

    Person p;
    p = s;  // 这里将子类对象赋值给父类对象
    p.print();

    return 0;
}

　　4.2 类对象的构造顺序：

　　　　a) 先构造父类;　

　　　　b) 构造成员对象;

　　　　c) 调用自己的构造函数;

　　　　d) 析构顺序与之相反。

5. 派生类对象的拷贝

　　5.1 对于父类的private 成员，子类的多参数构造函数如何去初始化呢？这里，在构造函数初始化列表中，可以直接调用父类的构造函数去初始化。　　

#include <iostream>
#include <string>
using namespace std;
/*
 *派生类构造函数初始化列表可以直接调用
 *基类的构造函数 用来初始化基类的私有成员
 */
class Person{
    public:
        Person(){}

        Person(int id,
               const string &name,
               int age)
            :id_(id),
             name_(name),
             age_(age){}

        ~Person(){}


        void set(int id, const string &name, int age){
            id_ = id;
            name_ = name;
            age_ = age;
        }

        void print() const{
            cout << id_ << " " << name_ << " " << age_ << endl;
        }

    private:
        int id_;
        string name_;
        int age_;
};
class Student : public Person{
    public:
        Student(int id,
               const string &name,
               int age,
               const string &school)
            :Person(id, name, age),
             school_(school){
             }

        void print() const{
            Person::print();
            cout << school_ << endl;
        }



    private:
        string school_;
};

int main(int argc, const char *argv[])
{
    Student s(123, "monica", 22, "hust");
    s.print();
    return 0;
}

 

　　5.2 派生类的默认构造函数和赋值运算符如何实现的。这里，通过调用基类的拷贝构造函数和赋值运算符来完成派生类对象的复制和赋值工作（要特别注意成员函数隐含了this指针，因此在传递参数时，不用特别声明）。

 　　　　

        Student(const Student &other) //派生类的拷贝构造函数
            :Person(other),
             school_(other.school_){}

        Student &operator=(const Student &other){
            if(this != &other){
                Person::operator=(other);
                school_ = other.school_;
            }
            return *this;
        }

　　

　　5.3 禁止复制类的继承，对于对个禁止复制类，每次都要讲拷贝构造函数和赋值运算符设为private，这就造成了大量的代码重复。这里，采用一个noncopyable类，该类将上述两个还是设为私有，并且只提供声明，任何禁止复制的类只要继承该类即可，注意 这里是私有继承(why?)。 一个派生类对象拥有父类的对象成员和自己的成员，因此子类对象在拷贝的时候也需要拷贝父类的成员，而我们在设计父类的时候已经将父类设置为禁止拷贝，因此子类对象就不能完成拷贝工作。

#include <iostream>
using namespace std;

class Noncopyable{
    public:
        Noncopyable(){};
        ~Noncopyable(){};
    private:
        Noncopyable(const Noncopyable &other);
        Noncopyable &operator=(const Noncopyable &other);
};
// 为什么这里是私有继承
class Test : private Noncopyable{

};

int main(int argc, const char *argv[])
{
    Test t;
    Test t2(t); //这里出错
    Test t3 = t;
    return 0;

}

6.基类和派生类的相互转化

　　6.1 基类的指针可以指向派生类的对象。但是使用该指针调用函数时，该指针把自己指向的派生类对象，当做基类对象。这里可以这样理解，父类的指针指向子类对象时，指针的值是子类对象的首地址，但是该指针所能感知的大小空间只是父类对象的大小的空间（在内存空间中，先存储父类的数据成员，再存储子类的其他数据成员），因而父类指针不能感知子类对象中的其他成员的存在。

　　6.2 用基类指针指向派生类对象，当使用该指针调用函数时：

　　　　a) 基类中有，派生类继承过去的函数：调用的是基类版本

　　　　b) 基类中没有，派生类自行添加的函数：无法调用。

　　　　c) 派生类重写了基类的同名函数，此时通过基类指针调用的仍是基类的版本。

　　　　

#include <iostream>
#include <string>
#include <vector>

using namespace std;
/*
 * 基类的指针可以指向派生类的对象
 * 并且该指针可以调用从父类继承的函数
 * 对于派生类重写的函数 该指针调用的是基类的版本
 * 该指针无法调用派生类自己的函数 因为它把自己当做基类的指针
 */

class Person{
    public:
        Person(){}
        Person(int id, const string &name, int age)
            :id_(id),
             name_(name),
             age_(age)
        {}
        void set(int id, const string &name, int age){
            id_ = id;
            name_ = name;
            age_ = age;
        }

        void print() const{
            cout << id_ << " " << name_ << " " << age_ << endl;
        }

    protected:
        int id_;
        string name_;
        int age_;
};

class Student:public Person{
    public:
        Student(int id,
                const string &name,
                int age,
                const string school)
            :Person(id, name, age),
             school_(school)
        {}

        void set(int id, const string &name, int age, const string &school){
            id_ = id;
            name_ = name;
            age_ = age;
            school_ = school;
        }

        void print()const{

          cout << id_ << " " << name_ << " " << age_ << " " << school_ << endl;
        }

        void test(){
            cout << "base pointer can't call derived own func" << endl;
        }
    private:
        string school_;
};

int main(int argc, const char *argv[])
{
    Student s(123, "zhangsan", 22, "wangdao");
    Person *pt;
    pt = &s;  //该基类指针所感知的空间是父类对象大小的空间
    pt->print(); //对于派生类重写的函数。该指针调用的都是基类的版本

    //pt->test(); //父类指针无法调用 派生类自己的函数




    return 0;
}
ubuntu%

　　6.3 子类对象指针转换为父类对象指针时，是自动转换的，此时，指针所指向的内存空间缩 小，但是这片区域是存在的，且是一个父类对象空间，因而是没问题的。父类对象指针转 换为子类对象指针时，在语法上，必须要使用强制转换，此时，指针所指向的内存空间扩 大，但是后面扩大的区域可能不存在，或者是存储的其他数据，这导致不安全问题发生。

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class Person{
    public:
        Person(){}
        Person(int id, const string &name, int age)
            :id_(id),
             name_(name),
             age_(age)
        {}
        void set(int id, const string &name, int age){
            id_ = id;
            name_ = name;
            age_ = age;
        }

        void print() const{
            cout << id_ << " " << name_ << " " << age_ << endl;
        }

    protected:
        int id_;
        string name_;
        int age_;
};

class Student:public Person{
    public:
        Student(int id,
                const string &name,
                int age,
                const string school)
            :Person(id, name, age),
             school_(school)
        {}

        void set(int id, const string &name, int age, const string &school){
            id_ = id;
            name_ = name;
            age_ = age;
            school_ = school;
        }

        void print()const{

          cout << id_ << " " << name_ << " " << age_ << " " << school_ << endl;
        }

        void test(){
            cout << "base pointer can't call derived own func" << endl;
        }
    private:
        string school_;
};

int main(int argc, const char *argv[])
{
    Student s(123, "zhangsan", 22, "wangdao");
    Person *pt;
    Student *ps;
    ps = &s;

    pt = ps; // 派生类指针可以转化为基类指针

    Person p1;
    pt = &p1;

    ps = (Student *)pt; //将基类的指针转换为派生类的指针 需要类型转换
                        //但是这虽然在语法上可行，逻辑上是错误的
    return 0;
}

　　6.4 继承体系中有这样一个结论：派生类is基类。

　　　　a)  从下到上转化（派生类的指针转化为基类指针）没有任何问题；

　　　　b) 从上到下，需要程序员手工保证逻辑上的正确性。

　　6.5 继承体系中：

　　　　a) 从上到下是一个具体化的过程，这个过程有无数个选择，人可以转化成学生、工人、教师多种型别。

　　　　b) 从下到上是一个抽象、泛化的过程，这里只存在一种选择。

　　6.6 从上到下的转化称为向下塑形，本质上是不安全的，需要谨慎使用。

 

7.静态绑定和动态绑定

　　7.1 以函数重载为例，编译器在编译期间就可以确定调用重载的哪个版本，也就是将函数调用与实际代码实现绑定。这个过程是在编译期间完成的，所以称为静态绑定（static binding），或者早绑定。

#include <iostream>
using namespace std;
/*
 * 静态绑定
 *
 */

class Animal{
    public:
        void display(){
            cout << "Animal..." << endl;
        }
};

class Cat : public Animal{
    public:
        void display(){
            cout << "Cat..." << endl;
        }
};

class Dog : public Animal{
    public:
        void display(){
            cout << "Dog ..." << endl;
        }
};


int main(int argc, const char *argv[])
{
    Cat c;
    c.display(); // Cat...
    Dog d;
    d.display(); // Dog...
    return 0;
}

　　7.2 满足动态绑定的条件：

　　　　a) 用基类的指针或者引用指向派生类对象；

　　　　b) 通过该指针或者引用调用的函数必须是virtual函数。

　　　　例1 ：满足动态绑定的条件a）

#include <iostream>
using namespace std;
/*
 * 动态绑定的条件
 * 这里的基类指针把所指向的派生类对象当做基类对象
 * 因此调用的函数还是基类的版本 没有实现动态绑定
 */

class Animal{
    public:
        void display(){
            cout << "Animal..." << endl;
        }
};

class Cat : public Animal{
    public:
        void display(){
            cout << "Cat..." << endl;
        }
};

class Dog : public Animal{
    public:
        void display(){
            cout << "Dog ..." << endl;
        }
};


int main(int argc, const char *argv[])
{
    Animal *pa;
    Cat c;
    pa = &c;
    pa->display(); //Animal...


    Dog d;
    pa = &d;
    pa->display();//Animal...


    return 0;
}

　　例2. 满足动态绑定的两个条件，这里，当编译器检测到pa->display();时，发现：

　　　　a) pa为Animal类型指针；

　　　　b) display为virtual函数。

　　　　于是编译器，停止绑定，而是等待到运行期，根据pa所实际指向的对象，来确定调用哪个函数。

#include <iostream>
using namespace std;
/*
 * 满足动态绑定的两个条件
 */
class Animal{
    public:
        virtual void display(){
            cout << "Animal..." << endl;
        }
};

class Cat : public Animal{
    public:
        void display(){
            cout << "Cat..." << endl;
        }
};

class Dog : public Animal{
    public:
        void display(){
            cout << "Dog ..." << endl;
        }
};


int main(int argc, const char *argv[])
{
    Animal *pa;
    Cat c;
    pa = &c;
    pa->display(); //Cat...


    Dog d;
    pa = &d;
    pa->display();//Dog...


    return 0;
}

　　7.3  动态绑定就是：编译器在编译期间并不确定到底调用哪个函数，而是把函数调用和实际代码绑定的过程推迟到运行期间。

8.虚函数

　　8.1 使用virtual修饰的函数称为虚函数。虚函数具有继承性，只要子类的同名函数参数与基类相同，返回值兼容，那么子类的该函数也是虚函数。

　　8.2 虚函数与普通函数的区别：

　　　　a) 普通函数总是采用静态绑定，根据指针类型来确定调用哪个函数。

　　　　b) 虚函数在触发动态绑定的情况下，根据指针所指向的实际对象类型，来决定调用哪个函数。

　　8.3 下列情形：

　　　　a) 基类中有display虚函数，派生类中也有display，参数与display相同，返回值兼容，此时派生类的display也是虚函数，那么我们称派生类的display覆盖了基类的display。

　　　　b) 基类中display，而且是virtual函数，但是派生类中的display不满足虚函数继承的条件（参数改变或者返回值不兼容），此时派生类中的display不是虚函数。

　　　　c) 基类中的display不是虚函数，派生类中display此时不必关心形参和返回值得问题。

　　　　d) 我们把后两者称为派生类函数隐藏了基类的display函数。

　　8.4  只需要记住动态绑定的情形，也就是函数覆盖的情形，其他所有的均为函数的隐藏。

　　8.5  函数覆盖：指的是派生类的virtual函数覆盖了基类的virtual函数。通过基类指针调用virtual函数来体现。

　　　　 函数隐藏：通过派生类对象调用自身改写的与基类同名的函数，此时调用的是自己改写的版本，所以称为隐藏。

　　8.6 函数重载称为一种编译期的多态，动态绑定称为运行时的多态，但是面向对象所指的多态（polymorphism），只包括动态绑定。

　　8.7 面向对象的第三个特征是动态绑定（Dynamic Binding）。

转载于:https://www.cnblogs.com/monicalee/p/3859102.html

继承规则及派生类的成员函数
lvxin15353715790的博客
09-19 2824
继承是面向对象复用的重要手段。通过继承定义一个类，继承是类型之间的关系建模，共享共有的东西，实现各自本质不同的东西。 成员访问限定符&amp;继承关系： 这是一个简单的继承关系： #include&lt;iostream&gt; #include&lt;Windows.h&gt; using namespace std; class person { public: char* nam...
C++Primer中级，1-10
萝卜丝儿皮尔
03-02 479
# include <iostream> # include <deque> int main() { using namespace std; deque<int> a; a.push_back(3); a.push_back(4); a.push_back(5); a.push_front(2); a.push_front(0); for (size_t ncount = 0; ncount < a.size(); ++ncount) /
路上前方--c++学习
lpf77的博客
10-26 573
前方太远的路，虽然听别人说过，而且很多人也都到达那里，但对我自己来讲还很模糊，我要做的就是紧盯本阶段的目标，一路前行。一、本阶段目标完成c++的基础概念学习，能够走出新手村。这是第一阶段的任务。现在已经接近尾声，开始策划第二阶段的提升目标以及提升方法了。
高效学习-笔记-左耳听风
大数据精读周刊
07-14 1161
文章目录高效学习：端正学习态度高效学习：源头、原理和知识地图信息源你要的是 “渔”，而不是 “鱼”。高效学习：深度，归纳和坚持实践举一反三写博客高效学习：如何学习和阅读代码高效学习：面对枯燥和量大的知识 高效学习：端正学习态度 如果你不能克服自己 DNA 中的弱点，不能端正自己的态度，不能坚持不能不断追问等，那么，无论有多好的方法，你都不可能学好。 在开始这一系列文章之前，我想说，如果你想从我这里得到一些速成的方法，那么你就不用往下看了，学习是不可能速成的。这里只有一些方法和技巧，是我这么多年来行之有效的
0712-----C++Primer听课笔记----------IO流
weixin_30737433的博客
07-12 81
0.不要试着从C++编译器的角度理解问题，而是从程序的语义着手。 1.控制台标准输入输出流的使用 1.1IO对象不可复制或者赋值。因此使用IO对象做参数必须使用非const 引用参数（非const因为对IO对象的读写会改变其状态）。 1.2当cin输入非法数据时，fail置为1，当cin遇到文件结尾（ctrl+D）时， fail和eof都为1。 #include <iostrea...
0717-----C++Primer听课笔记----------复制控制
weixin_30719711的博客
07-17 90
1.默认拷贝构造函数 1.1 编译器自动为我们合成一个拷贝构造函数。A(const A &). 1.2 对象复制的时机： a) 显式复制。 b) 使用对象做形参 c) 使用对象做返回值 d) 往容器中放入对象 #include <iostream> #include <string> #include <vector> using...
0718-----C++Primer听课笔记----------运算符重载
weixin_30268921的博客
07-19 171
0.两个要点 a) 一个空类，编译器自动合成默认无参构造函数、析构函数、拷贝构造函数、赋值运算符。 b) 在编写类的时候，必须严格区分对象是否可复制。 1.运算符重载之 string类 1.1 运算符重载的几个要点: a) 运算符重载可以有成员函数和友元函数的形式，后者比前者多一个参数。 b) =和+=必须重载为成员函数的形式（不太理解原因）。 c) 输入和输出必须为友元函数的形式。...
0715-----C++Primer听课笔记-----------函数指针 、单例模式
weixin_30414635的博客
07-16 113
1.函数指针 1.1 普通成员函数指针包含类名信息以及const属性，指向具体函数是必须加上&符号。 #include <iostream> using namespace std; class Test{ public: void setValue(const string &s, int a){ ...
0713-----C++Primer听课笔记----------类和对象
weixin_30446613的博客
07-13 69
1.要求：将一篇文章录入，然后实现查询: a)查询可以输入字符或者字符串 b)将包含它们的单词输出 c)允许重复 d)如果输入查询有空格，当多个处理 Ex： 输入ro，应该打印出“microsift” 输入”he wr”，则查询两次 1.1 不用类实现 #include <iostream> #include <string> #include &...
(完整版)C++-primer-plus(第6版)中文版-编程练习答案(word版).doc
11-13
C++ Programming Fundamentals C++ 是一种高效、灵活的编程语言，广泛应用于操作系统、应用程序、游戏开发等领域。了解 C++ 的基础概念和编程技术是任何程序员的基本功。下面从给定的文件中生成的知识点： 1. 基本...
(完整版)C-Primer-Plus第6版编程练习答案(已下载).doc
11-15
C 语言程序设计基础知识点总结 本文档总结了 C 语言程序设计的基础知识点，涵盖了变量、数据类型、运算符、控制流语句、函数和数组等方面的内容。 变量和数据类型 * 变量是存储值的命名存储单元 ...
hugo-primer:基于GitHub的Primer CSS的Hugo主题
05-08
雨果·普里默（Hugo-Primer） 一个基于GitHub的Primer CSS的简单漂亮的Hugo主题| 如果您习惯使用GitHub风格的页面，那么此主题将是一个完美的选择。 Hugo-Primer是基于GitHub风格CSS主题：Primer，并在其上添加了...
system-design-primer-master.zip
12-19
"system-design-primer-master.zip" 文件包含了一个全面的资源，帮助初学者和有经验的工程师深入理解系统设计的核心概念。这个压缩包可能包含了源代码、文档、笔记等内容，旨在引导学习者掌握系统设计的关键知识点。...
mysql性能优化工具--tuner-primer使用介绍
09-10
Tuner-Primer是一个专门用于MySQL性能调优的脚本工具，由Matthew Montgomery开发，它可以帮助管理员识别潜在的问题并提供改进建议。下面将详细介绍Tuner-Primer的使用方法及其返回数据的分析。 首先，你需要下载...
Qt5 图形与动画详细讲解
black book发布
08-20 1093
本文介绍了Qt5图形系统的核心概念和框架。首先讲解了基础绘图机制，包括QPaintDevice和QPainter的配合使用，以及坐标系系统和双缓冲技术。接着重点介绍了Graphics View框架，由QGraphicsScene、QGraphicsItem和QGraphicsView三部分组成，适合管理大量可交互图形项。最后阐述了Qt动画框架，特别是QPropertyAnimation的使用方法，以及在Graphics View中实现动画的两种方式。全文通过代码示例展示了如何在Qt中实现图形绘制、场景管理和
C++11中的互斥锁，条件变量，生产者-消费者示例
cyz322649的博客
08-20 1043
本文介绍了C++11中的互斥锁和条件变量机制。主要内容包括：1. 互斥锁的RAII封装类（lock_guard和unique_lock）及其自动管理功能，避免手动加解锁带来的死锁风险。2. 条件变量的作用原理，重点讲解了wait()函数的两种形式及其防虚假唤醒机制。3. 生产者-消费者模型的完整实现示例，展示了互斥锁与条件变量的协同工作流程。4. 详细分析了线程执行过程中获取锁、检查条件、等待通知和业务处理的时序关系。这些机制共同构成了C++多线程编程中安全高效的同步解决方案。
C++ 运算符：从基础到高阶的完整指南
最新发布
正在在摸鱼的博客
08-22 355
运算符重载是C++支持多态性的核心特性之一，允许程序员为自定义类型赋予运算符的语义化操作能力。其本质是通过函数重载机制实现的，编译器会根据操作数类型选择最匹配的运算符函数。+=
C++ STL -4 | vector
电子异术博物馆
08-22 555
介绍C++中std::vector的使用技巧与底层机制。重点包括：1）vector的动态数组特性与基本操作；2）容量管理（size/capacity区别、预分配优化）；3）底层实现（连续存储、扩容机制）；4）特殊用法（swap回收内存、emplace高效构造）；5）vector<bool>的特化实现与陷阱；6）开发注意事项（迭代器失效、性能优化等）。适合有一定基础的开发者掌握vector的进阶特性，提升使用效率与规避常见错误。
C++ Primer 5th解决方案：涵盖第8-19章
此外，资源的文件名提示为Cpp-Primer-main，这可能意味着主目录包含了相关章节的解决方案代码文件。在提供的文件列表中虽然没有列出各个章节的详细解决方案文件名，但可以推断该目录包含了针对第8章到第19章每个部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值