C/C++基础详解（三）

1.继承与组合的优缺点？

继承是指派生类对象对父类对象成员变量和成员函数的的继承，可以通过重写来对父类对象进行扩展，优点;1.代码复用，减少冗余代码 2.提高开发效率缺点：父类函数的实现细节在子类中是可见的 2.在编译时就确定了父类继承的方法，无法改变 3.父类的成员函数的改变会影响子类的成员函数，高耦合，不符合C++面向对象的编程思想

组合是指一个类对象在另一个类中以成员变量形式存在，优点：1.以成员变量存在的类内部实现细节对另一个类是不可见的，2.低耦合，3.动态绑定缺点;1.可能定义过多对象，代码量过大 2.对每个类的接口都需要仔细实现其细节

2.什么是C++标准库？

C++标准库分为以下几类：

1.STL库：存在容器、迭代器、算法和函数对象等

2.IO库：输入输出相关的库函数

3.字符串库：string

4.线程库：锁mutex、线程thread、原子操作atomic

5.其他组件:智能指针、工具类和try+throw+catch机制

**3.能否在任何情况下类都使用memset(this,0,sizeof (*this))**

对于普通的类POD，当然使用memset是没有任何问题的，但是当面对存在虚函数的类时，由于存在虚表指针，使用其就会将虚表指针置为nullptr，找不到虚函数表了，显然无法使用；面对类中存在STL成员时，直接使用memset也会破坏其内部结构，由此可见，并不是什么时候都适合使用memset的

4.用C语言实现C++继承和多态

cpp 复制代码

//首先，我们先来实现C++继承和多态
class A
{
public:
     virtual void func()
     {
          std::cout<<"A::func()<<std::endl;
     }
};

class B: public A
{
public:
    virtual void func()
    {
        std::cout<<"B::func()<<std::endl;
    }
};

void test1()
{
    A a;
    B b;
    A* ptr = &a;
    ptr->func();//调用父类函数
    ptr = &b;
    ptr->func();//调用子类函数
}

现在我们利用C语言实现

cpp 复制代码

//注意点：C语言结构体内无成员函数，因此我们要利用函数指针
typedef void (*fptr)();

struct A
{
    fptr _pa;
};

struct B
{
    A a;   
};

void funca()
{
    std::cout<<"A::func()"<<std::endl;
}

void funcb()
{
    std::cout<<"B::func()"<<std::endl;
}

void test2()
{
    A _a;
    B _b;
    _a._pa = funca;
    _b._a._pa = funcb;
    A* p = &_a;
    p->_pa();
    p =(A*)&_b;
    p->_pa();
}

5.介绍下几种不同的锁

互斥锁：

最基本的锁，作用是保证同一时间只有一个线程可以访问共享资源，其余线程阻塞，用于保护临界区资源，例如：

cpp 复制代码

#include <iostream>
#include <mutex>

int main()
{
    std::mutex _mtx;
    _mtx.lock();
    //访问临界区资源
    _mtx.unlock();
    return 0;
}

递归锁：

允许统一线程多次加锁，防止出现死锁情况（互斥锁多次加锁就会出现死锁情况），例如：

cpp 复制代码

#include <iostream>
#include <mutex>
std::recursive_mutex _mtx;
void func(int n)
{
    _mtx.lock();
    n--;
    if(n > 0)
    {
       func(n);
    }
    _mtx.unlock();
}

读写锁：

允许多个线程同时读取共享内容，但是只允许一个线程修改该部分内容，适用于数据库、文件系统等读的次数远大于写的次数的系统，例如：

cpp 复制代码

#include <iostream>
#include <shared_mutex>//C++17引入

std::shared_mutex _mtx;

void read_data()
{
    //读操作
    _mtx.lock_shared();
    //读取
    _mtx.unlock_shared();
}

void write_data()
{
    //写操作
    _mtx.lock();
    //写
    _mtx.unlock();
}

自旋锁：

当一个线程想获取其他线程已经获取的锁时，不会进入睡眠状态，而是在一个循环中不断去检查锁的状态（这也称为自旋）这个过程也被称为忙等待,适用于多线程同步情况下

以上就是这次的内容，感谢你的支持！！！