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++继承和多态
//首先，我们先来实现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语言实现
//注意点：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.介绍下几种不同的锁
互斥锁：
最基本的锁，作用是保证同一时间只有一个线程可以访问共享资源，其余线程阻塞，用于保护临界区资源，例如：
#include <iostream>
#include <mutex>
int main()
{
std::mutex _mtx;
_mtx.lock();
//访问临界区资源
_mtx.unlock();
return 0;
}递归锁：
允许统一线程多次加锁，防止出现死锁情况（互斥锁多次加锁就会出现死锁情况），例如：
#include <iostream>
#include <mutex>
std::recursive_mutex _mtx;
void func(int n)
{
_mtx.lock();
n--;
if(n > 0)
{
func(n);
}
_mtx.unlock();
}读写锁：
允许多个线程同时读取共享内容，但是只允许一个线程修改该部分内容，适用于数据库、文件系统等读的次数远大于写的次数的系统，例如：
#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();
}自旋锁：
当一个线程想获取其他线程已经获取的锁时，不会进入睡眠状态，而是在一个循环中不断去检查锁的状态（这也称为自旋）这个过程也被称为忙等待,适用于多线程同步情况下
以上就是这次的内容，感谢你的支持！！！