c/c++知识点总结 6

今天简单说说设计模式，无论是在面试还是在实际的工作中数据模式都是很常用的，它可以帮助我们提高效率，优化代码。我本人常用的数据模式是友元、单例、工厂和观察者，下面呢就着这四种简单的总结一下，有什么不对的希望大家批评指正。

1.友元模式：在c++中类的私有变量和方法不能被外部类直接使用，也不能够被继承，因此引入了友元类，可以使用类中的私有变量和方法，虽然对程序的封装性有一定的破坏，但是很实用。

利用关键字friend:friend class A；此时A就是当前所在类的朋友，当前类可以调用A 的私有方法和变量

2.单理模式：

单例模式需要保证以下三点：

a.只能有一个实力化对象

b.必须自己提供一个实例化对象

c.必须提供一个获取实例化对象的接口

常见的单例实现方式分为饿汉和懒汉模式。顾名思义

前者指的是在单例类定义的时候就初始化，在访问量大或者访问的线程多的时候使用此种方式。以空间换时间

Singleton* Singleton::m_pSingleton = new Singleton();

Singleton* Singleton::getInstance()
{
    return m_pSingleton;
}

后者指的是实例化对象在第一次调用获取对象接口的时候才创建，在访问量较小的时候使用此种方式，以时间换空间。

Singleton* Singleton::getInstance()
{
    if(m_pSingleton == NULL)
    {
        m_pSingleton = new Singleton;
    }
    return m_pSingleton;
}

//线程安全的懒汉单例模式

Singleton* Singleton::getInstance()
{
    if(m_pSingleton == NULL)
    {
        mt.lock();
        if(m_pSingleton == NULL)
        {
            m_pSingleton = new Singleton();
        }
        mt.unlock();
    }
    return m_pSingleton;
}
3.工厂模式：

在创建对象的时候不会对客户端曝露逻辑，而且只需要一个接口来指向新创建的对象，我们只需要一个产品对应一个工厂，当有新的产品出现时，只需要新增工厂即可,当然这也是其缺点之一

#include <iostream>
 ​
 using namespace std;
 ​
 //定义产品类型信息
 typedef enum
 {
     TypeA,
     TypeB
 }Product_Type;
 ​
 //抽象产品类
 class Product
 {
 public:
     virtual const string& type() = 0;
 };
 ​
 //具体的产品类
 class ProductA : public Product
 {
 public:
     ProductA():Product(),m_strType("ProductA")
     {
     }
 ​
     const string& type() override
     {
         cout << m_strType.data() << endl;
         return m_strType;
     }
 private:
     string m_strType;
 };
 ​
 //具体的产品类
 class ProductB : public Product
 {
 public:
     ProductB():Product(),m_strType("ProductB")
     {
     }
     const string& type() override
     {
         cout << m_strType.data() << endl;
         return m_strType;
     }
 ​
 private:
     string m_strType;
 }; 
 ​
 //工厂类
 class ProductFactory
 {
 public:
     //根据产品信息创建具体的产品类实例，返回一个抽象产品类
     Product* createProduct(Product_Type type)
     {
         switch(type)
         {
         case TypeA:
             return new ProductA();
         case TypeB:
             return new ProductB();
         default:
             return nullptr;
         }
     }
 };
 ​
 ​
 int main()
 {
     ProductFactory* factory = new ProductFactory();
     Product* ProductA = factory->createProduct(TypeA);
     ProductA->type();
     Product* ProductB = factory->createProduct(TypeB);
     ProductB->type();
 ​
     delete ProductB;
     ProductB = nullptr;
     delete ProductA;
     ProductA = nullptr;
     delete factory;
     factory = nullptr;
 ​
     return 0;
 }

4.观察者模式：

观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都要得到通知并自动更新。

观察者模式从根本上讲必须包含两个角色：观察者和被观察对象。

被观察对象自身应该包含一个容器来存放观察者对象，当被观察者自身发生改变时通知容器内所有的观察者对象自动更新。

观察者对象可以注册到被观察者的中，完成注册后可以检测被观察者的变化，接收被观察者的通知。当然观察者也可以被注销掉，停止对被观察者的监控。