C++002常见设计模式

最新推荐文章于 2023-04-04 14:33:18 发布
最新推荐文章于 2023-04-04 14:33:18 发布
阅读量362 收藏
点赞数
分类专栏： C++ 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/opera95/article/details/51220079
版权

饿汉式的单例模式

1.1 问题

单例模式使用私有构造函数的方法禁止在类外部创建实例，而类自己使用静态成员变量的方法来维护其唯一实例，并提供访问该实例的方法。

饿汉式单例模式的优点是加载进程时静态创建单例对象，线程安全；缺点是无论使用与否，总要创建一个实例。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：饿汉式的单例模式

代码如下：


    
    
  1. #include <iostream>
  3. class Singleton
  4. {
  5. private:
  6.     Singleton (void)
  7.     {
  8.     }
  9.     Singleton (Singleton const& that)
  10.     {
  11.     }
  12.     static Singleton s_instance;
  13. public:
  14.     static Singleton& getInstance (void)
  15.     {
  16.         return s_instance;
  17.     }
  18. };
  20. Singleton Singleton::s_instance;
  22. int main(int argc, const char * argv[])
  23. {
  24.     
  25.   
  26.     Singleton& a = Singleton::getInstance();
  27.     std::cout << std::hex << &a << std::endl;
  28.     Singleton& b = Singleton::getInstance();
  29.     std::cout << std::hex << &b << std::endl;
  30.     
  31.     return 0;
  32. }

上述代码中，以下代码：


    
    
  1. private:
  2.     Singleton (void)
  3.     {
  4.     }
  5.     Singleton (Singleton const& that)
  6.     {
  7.     }

通过将类Singleton的构造函数和拷贝构造函数定义成私有的，来禁止在类外创建该类的对象。

上述代码中，以下代码：


    
    
  1.     static Singleton s_instance;

将单例类的唯一对象实例，实现为其静态成员变量。虽然静态成员变量s_instance需要在类的外部实例化，但它毕竟是Singleton类的成员(尽管是静态成员)，依然属于类的内部元素，可以调用该类的私有构造函数。

上述代码中，以下代码：


    
    
  1.     static Singleton& getInstance (void)
  2.     {
  3.         return s_instance;
  4.     }

通过成员函数getInstance来获得类Singleton的唯一对象实例。

1.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <iostream>
  3. class Singleton
  4. {
  5. private:
  6.     Singleton (void)
  7.     {
  8.     }
  9.     Singleton (Singleton const& that)
  10.     {
  11.     }
  12.     static Singleton s_instance;
  13. public:
  14.     static Singleton& getInstance (void)
  15.     {
  16.         return s_instance;
  17.     }
  18. };
  20. Singleton Singleton::s_instance;
  22. int main(int argc, const char * argv[])
  23. {
  24.     
  25.   
  26.     Singleton& a = Singleton::getInstance();
  27.     std::cout << std::hex << &a << std::endl;
  28.     Singleton& b = Singleton::getInstance();
  29.     std::cout << std::hex << &b << std::endl;
  30.     
  31.     return 0;
  32. }

2 懒汉式的单例模式

2.1 问题

单例模式使用私有构造函数的方法禁止在类外部创建实例，而类自己使用静态成员变量的方法来维护其唯一实例，并提供访问该实例的方法。

懒汉式单例模式的优点是用则创建，不用不创建，什么时候用什么时候创建；缺点是首次访问时动态创建单例对象，在多线程应用中，存在线程不安全的问题。

2.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：懒汉式的单例模式

代码如下：


    
    
  1. #include <iostream>
  3. class Singleton
  4. {
  5. private:
  6.     Singleton (void)
  7.     {
  8.     }
  9.     Singleton (Singleton const& that)
  10.     {
  11.     }
  12.     static Singleton* s_instance;
  13. public:
  14.     static Singleton& getInstance (void)
  15.     {
  16.         if (! s_instance)
  17.             s_instance = new Singleton;
  18.         return *s_instance;
  19.     }
  20. };
  22. Singleton* Singleton::s_instance = NULL;
  24. int main(int argc, const char * argv[])
  25. {
  26.     
  27.   
  28.     Singleton& a = Singleton::getInstance();
  29.     std::cout << std::hex << &a << std::endl;
  30.     Singleton& b = Singleton::getInstance();
  31.     std::cout << std::hex << &b << std::endl;
  32.     
  33.     return 0;
  34. }

上述代码中，以下代码：


    
    
  1. private:
  2.     Singleton (void)
  3.     {
  4.     }
  5.     Singleton (Singleton const& that)
  6.     {
  7.     }

通过将类Singleton的构造函数和拷贝构造函数定义成私有的，来禁止在类外创建该类的对象。

上述代码中，以下代码：


    
    
  1.     static Singleton* s_instance;

声明了类Singleton的静态指针，该指针在类外定义时，被初始化为空，如以下代码所示：


    
    
  1. Singleton* Singleton::s_instance = NULL;

上述代码中，以下代码：


    
    
  1.     static Singleton& getInstance (void)
  2.     {
  3.         if (! s_instance)
  4.             s_instance = new Singleton;
  5.         return *s_instance;
  6.     }

通过成员函数getInstance来获得类Singleton的唯一对象实例。与饿汉式的区别是在函数getInstance第一次被调用时，才创建唯一对象实例，而不是在创建程序一开始就创建唯一对象实例。

2.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <iostream>
  3. class Singleton
  4. {
  5. private:
  6.     Singleton (void)
  7.     {
  8.     }
  9.     Singleton (Singleton const& that)
  10.     {
  11.     }
  12.     static Singleton* s_instance;
  13. public:
  14.     static Singleton& getInstance (void)
  15.     {
  16.         if (! s_instance)
  17.             s_instance = new Singleton;
  18.         return *s_instance;
  19.     }
  20. };
  22. Singleton* Singleton::s_instance = NULL;
  24. int main(int argc, const char * argv[])
  25. {
  26.     
  27.   
  28.     Singleton& a = Singleton::getInstance();
  29.     std::cout << std::hex << &a << std::endl;
  30.     Singleton& b = Singleton::getInstance();
  31.     std::cout << std::hex << &b << std::endl;
  32.     
  33.     return 0;
  34. }

3 考虑线程安全的单例模式

3.1 问题

饿汉式单例模式在多线程应用中，由于是多线程并发执行，有可能创建出多个对象实例，存在线程不安全的问题。借助互斥锁能够防止单例对象在不同线程中被重复创建。

3.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：考虑线程安全的单例模式

代码如下：


    
    
  1. #include <iostream>
  3. class Singleton
  4. {
  5. private:
  6.     Singleton (void)
  7.     {
  8.     }
  9.     Singleton (Singleton const& that)
  10.     {
  11.     }
  12.     static Singleton* s_instance;
  13.     static pthread_mutex_t s_mutex;
  14. public:
  15.     static Singleton& getInstance (void)
  16.     {
  17.         if (! s_instance)
  18.         {
  19.             pthread_mutex_lock (&s_mutex);
  20.             if (! s_instance)
  21.                 s_instance = new Singleton;
  22.             pthread_mutex_unlock (&s_mutex);
  23.         }
  24.         return *s_instance;
  25.     }
  26. };
  28. Singleton* Singleton::s_instance = NULL;
  29. pthread_mutex_t Singleton::s_mutex = PTHREAD_MUTEX_INITIALIZER;_
  30. int main(int argc, const char * argv[])
  31. {
  32.     
  33.   
  34.     Singleton& a = Singleton::getInstance();
  35.     std::cout << std::hex << &a << std::endl;
  36.     Singleton& b = Singleton::getInstance();
  37.     std::cout << std::hex << &b << std::endl;
  38.     
  39.     return 0;
  40. }

上述代码中，以下代码：


    
    
  1.     static Singleton& getInstance (void)
  2.     {
  3.         if (! s_instance)
  4.         {
  5.             pthread_mutex_lock (&s_mutex);
  6.             if (! s_instance)
  7.                 s_instance = new Singleton;
  8.             pthread_mutex_unlock (&s_mutex);
  9.         }
  10.         return *s_instance;
  11.     }

在获得类Singleton的唯一对象实例的成员函数getInstance中，通过加互斥锁的方法来保证多线程安全。如下代码：


    
    
  1.             pthread_mutex_lock (&s_mutex);

首先设置互斥变量s_mutex，此时如果有其它线程已经设置了该变量，则当前线程就等待，直到其他线程释放互斥变量，此线程才重新开始执行。

以下代码：


    
    
  1.             pthread_mutex_unlock (&s_mutex);

是释放互斥变量s_mutex。

3.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <iostream>
  3. class Singleton
  4. {
  5. private:
  6.     Singleton (void)
  7.     {
  8.     }
  9.     Singleton (Singleton const& that)
  10.     {
  11.     }
  12.     static Singleton* s_instance;
  13.     static pthread_mutex_t s_mutex;
  14. public:
  15.     static Singleton& getInstance (void)
  16.     {
  17.         if (! s_instance)
  18.         {
  19.             pthread_mutex_lock (&s_mutex);
  20.             if (! s_instance)
  21.                 s_instance = new Singleton;
  22.             pthread_mutex_unlock (&s_mutex);
  23.         }
  24.         return *s_instance;
  25.     }
  26. };
  28. Singleton* Singleton::s_instance = NULL;
  29. pthread_mutex_t Singleton::s_mutex = PTHREAD_MUTEX_INITIALIZER;_
  30. int main(int argc, const char * argv[])
  31. {
  32.     
  33.   
  34.     Singleton& a = Singleton::getInstance();
  35.     std::cout << std::hex << &a << std::endl;
  36.     Singleton& b = Singleton::getInstance();
  37.     std::cout << std::hex << &b << std::endl;
  38.     
  39.     return 0;
  40. }

4 通过成员指针访问对象

4.1 问题

成员变量指针的本质，就是特定成员变量在类对象实例中的相对地址。成员变量指针解引用，就是根据类对象实例的起始地址，结合成员变量指针中的相对地址，计算出具体成员变量的绝对地址，并访问之。类的静态成员变量不是对象的一部分，不需要根据相对地址计算绝对地址，也不需要通过对象或其指针解引用。

成员函数并不存储在对象中，不存在根据相对地址计算绝对地址的问题，但是需要通过对象或对象指针对成员函数指针解引用，其目的只有一个，即提供this指针。类的静态成员函数没有this指针，无需调用对象。

静态成员与对象无关，因此静态成员指针与普通指针并没有任何本质性区别。

4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：通过成员变量指针访问成员变量

代码如下：


    
    
  1. #include <iostream>
  3. class Student
  4. {
  5. public:
  6.     std::string m_name;
  7.     std::string m_sex;
  8.     int m_age;
  9.     int m_no;
  10. };
  12. int main(int argc, const char * argv[])
  13. {
  14.     
  15.   
  16.     int Student::*p_age = &Student::m_age;
  17.     Student student;
  18.     student.*p_age = 10;
  19.     std::cout << student.m_age << std::endl;
  20.     
  21.     return 0;
  22. }

上述代码中，以下代码：


    
    
  1.     int Student::*p_age = &Student::m_age;

定义了一个成员变量指针p_age，指向类Student的变量成员m_age.

上述代码中，以下代码：


    
    
  1.     Student student;
  2.     student.*p_age = 10;

定义了一个类Student的对象student，然后通过成员变量指针p_age，将对象student中的变量成员m_age赋值为10，这被称为解引用。其实，成员变量指针p_age指向的是变量成员m_age在对象student中的相对地址。“.*”是一个独立的运算符，成员指针解引用运算符。

步骤二：通过成员函数指针访问成员函数

代码如下：


    
    
  1. #include <iostream>
  3. class Student
  4. {
  5. public:
  6.     std::string m_name;
  7.     std::string m_sex;
  8.     int m_age;
  9.     int m_no;
  10.     
  11.     void who (void) const
  12.     {
  13.         std::cout <<  "我是" << m_name << "，性别" << m_sex << "，今年" << m_age << "岁，学号" << m_no << std::endl;
  14.     }
  15. };
  17. int main(int argc, const char * argv[])
  18. {
  19.     
  20.   
  21.     int Student::*p_age = &Student::m_age;
  22.     Student student;
  23.     student.*p_age = 10;
  24.     std::cout << student.m_age << std::endl;
  25.     
  26.     student.m_name = "张三";
  27.     student.m_no = 12;
  28.     student.m_sex = "男";
  29.     void (Student::*p_who) (void) const = &Student::who;
  30.     (student.*p_who)();
  31.     return 0;
  32. }

上述代码中，以下代码：


    
    
  1.     void (Student::*p_who) (void) const = &Student::who;

定义了一个成员函数指针p_who，指向类Student的函数成员who。

上述代码中，以下代码：


    
    
  1.     (student.*p_who)();

通过成员函数指针p_who，调用类Student的成员函数who，这被称为解引用。添加student的目的只有一个，即提供this指针。

步骤三：通过静态成员指针访问静态成员

代码如下：


    
    
  1. #include <iostream>
  3. class Student
  4. {
  5. public:
  6.     std::string m_name;
  7.     std::string m_sex;
  8.     int m_age;
  9.     int m_no;
  10.     
  11.     static int s_count;
  12.     
  13.     void who (void) const
  14.     {
  15.         std::cout <<  "我是" << m_name << "，性别" << m_sex << "，今年" << m_age << "岁，学号" << m_no << std::endl;
  16.     }
  17.     
  18.     static void inc (void)
  19.     {
  20.         s_count++;
  21.     }
  22. };
  24. int Student::s_count = 0;
  26. int main(int argc, const char * argv[])
  27. {
  28.     
  29.   
  30.     int Student::*p_age = &Student::m_age;
  31.     Student student;
  32.     student.*p_age = 10;
  33.     std::cout << "age = " << student.m_age << std::endl;
  34.     
  35.     student.m_name = "张三";
  36.     student.m_no = 12;
  37.     student.m_sex = "男";
  38.     void (Student::*p_who) (void) const = &Student::who;
  39.     (student.*p_who)();
  40.     
  41.     int* p_count = &Student::s_count;
  42.     *p_count = 10;
  43.     std::cout << "count = " << Student::s_count << std::endl;
  44.     
  45.     void (*p_inc)(void) = Student::inc;
  46.     (*p_inc)();
  47.     std::cout << "count = " << Student::s_count << std::endl;
  48.     
  49.     return 0;
  50. }

上述代码中，以下代码：


    
    
  1.     int* p_count = &Student::s_count;
  2.     *p_count = 10;

定义了一个静态成员指针变量p_count，指向类Student的静态变量成员s_count。静态成员指针与普通指针并没有任何本质性区别，只是成员指针受访问控制属性约束。

上述代码中，以下代码：


    
    
  1.     void (*p_inc)(void) = Student::inc;

定义了一个静态成员函数指针p_inc，指向类Student的函数成员inc。

上述代码中，以下代码：


    
    
  1.     (*p_inc)();

通过静态成员函数指针p_inc，调用类Student的成员函数inc。类的静态成员函数没有this指针，无需调用对象。

4.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <iostream>
  3. class Student
  4. {
  5. public:
  6.     std::string m_name;
  7.     std::string m_sex;
  8.     int m_age;
  9.     int m_no;
  10.     
  11.     static int s_count;
  12.     
  13.     void who (void) const
  14.     {
  15.         std::cout <<  "我是" << m_name << "，性别" << m_sex << "，今年" << m_age << "岁，学号" << m_no << std::endl;
  16.     }
  17.     
  18.     static void inc (void)
  19.     {
  20.         s_count++;
  21.     }
  22. };
  24. int Student::s_count = 0;
  26. int main(int argc, const char * argv[])
  27. {
  28.     
  29.   
  30.     int Student::*p_age = &Student::m_age;
  31.     Student student;
  32.     student.*p_age = 10;
  33.     std::cout << "age = " << student.m_age << std::endl;
  34.     
  35.     student.m_name = "张三";
  36.     student.m_no = 12;
  37.     student.m_sex = "男";
  38.     void (Student::*p_who) (void) const = &Student::who;
  39.     (student.*p_who)();
  40.     
  41.     int* p_count = &Student::s_count;
  42.     *p_count = 10;
  43.     std::cout << "count = " << Student::s_count << std::endl;
  44.     
  45.     void (*p_inc)(void) = Student::inc;
  46.     (*p_inc)();
  47.     std::cout << "count = " << Student::s_count << std::endl;
  48.     
  49.     return 0;
  50. }

    
    

     
     

    
    

    
    

     
     

    
    

   
   

    
    
 简单工厂模式
11.1 问题
全部由纯虚函数构成的抽象类称为纯抽象类或接口。面向抽象编程，使得所有基于接口编写的代码，在子类被更替后，无需做任何修改或只需做很少的修改，就能在新子类上正确运行。
11.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：简单工厂模式
代码如下：

     
     

      
      

       
       

       
       
        
        
  1. #include <iostream>
  3. typedef enum ProductTypeTag
  4. {
  5.     TypeA,
  6.     TypeB,
  7.     TypeC
  8. }PRODUCTTYPE;
  10. // Here is the product class
  11. class Product
  12. {
  13. public:
  14.     virtual void show() = 0;
  15. };
  17. class ProductA : public Product
  18. {
  19. public:
  20.     void show(void)
  21.     {
  22.         std::cout << "I'm ProductA" << std::endl;
  23.     }
  24. };
  26. class ProductB : public Product
  27. {
  28. public:
  29.     void show(void)
  30.     {
  31.         std::cout << "I'm ProductB" << std::endl;
  32.     }
  33. };
  35. class ProductC : public Product
  36. {
  37. public:
  38.     void show(void)
  39.     {
  40.         std::cout << "I'm ProductC" << std::endl;
  41.     }
  42. };
  44. // Here is the Factory class
  45. class Factory
  46. {
  47. public:
  48.     Product* CreateProduct(PRODUCTTYPE type)
  49.     {
  50.         switch (type)
  51.         {
  52.             case TypeA:
  53.                 return new ProductA;
  54.                 
  55.             case TypeB:
  56.                 return new ProductB;
  57.                 
  58.             case TypeC:
  59.                 return new ProductC;
  60.                 
  61.             default:
  62.                 return NULL;
  63.         }
  64.     }
  65. };
  67. int main(int argc, char *argv[])
  68. {
  69.     // First, create a factory object
  70.     Factory *ProductFactory = new Factory();
  71.     Product *productObjA = ProductFactory->CreateProduct(TypeA);
  72.     if (productObjA != NULL)
  73.         productObjA->show();
  74.     
  75.     Product *productObjB = ProductFactory->CreateProduct(TypeB);
  76.     if (productObjB != NULL)
  77.         productObjB->show();
  78.     
  79.     Product *productObjC = ProductFactory->CreateProduct(TypeC);
  80.     if (productObjC != NULL)
  81.         productObjC->show();
  82.     
  83.     delete ProductFactory;
  84.     delete productObjA;
  85.     delete productObjB;
  86.     delete productObjC;
  87.     
  88.     return 0;
  89. }

      
      

     
     
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1. class Product
  2. {
  3. public:
  4.     virtual void show() = 0;
  5. };

      
      

     
     
定义了一个抽象产品类Product。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1. class ProductA : public Product
  2. {
  3. public:
  4.     void show(void)
  5.     {
  6.         std::cout << "I'm ProductA" << std::endl;
  7.     }
  8. };
  10. class ProductB : public Product
  11. {
  12. public:
  13.     void show(void)
  14.     {
  15.         std::cout << "I'm ProductB" << std::endl;
  16.     }
  17. };
  19. class ProductC : public Product
  20. {
  21. public:
  22.     void show(void)
  23.     {
  24.         std::cout << "I'm ProductC" << std::endl;
  25.     }
  26. };

      
      

     
     
定义了3个具体产品类。在这3个类中，分别对纯虚函数show进行了实现。还可能有更多的具体产品类。这样就造成创建对象时，对象多而杂。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1. class Factory
  2. {
  3. public:
  4.     Product* CreateProduct(PRODUCTTYPE type)
  5.     {
  6.         switch (type)
  7.         {
  8.             case TypeA:
  9.                 return new ProductA;
  10.                 
  11.             case TypeB:
  12.                 return new ProductB;
  13.                 
  14.             case TypeC:
  15.                 return new ProductC;
  16.                 
  17.             default:
  18.                 return NULL;
  19.         }
  20.     }
  21. };

      
      

     
     
定义了一个简单工厂类Factory，其中含有一个成员函数CreateProduct用于生成具体产品对象，以简化创建对象时，对象多而杂的现象。这样就能把对象的创建和操作两部分分离开，方便后期的程序扩展和维护。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     Factory *ProductFactory = new Factory();
  2.     Product *productObjA = ProductFactory->CreateProduct(TypeA);
  3.     if (productObjA != NULL)
  4.         productObjA->show();

      
      

     
     
在主程序中，使用简单工厂类Factory的CreateProduct函数生成具体产品对象，用抽象基类Product的指针实现多态。
11.3 完整代码
本案例的完整代码如下所示：

     
     

      
      

       
       

         
         
  1. #include <iostream>
  3. typedef enum ProductTypeTag
  4. {
  5.     TypeA,
  6.     TypeB,
  7.     TypeC
  8. }PRODUCTTYPE;
  10. // Here is the product class
  11. class Product
  12. {
  13. public:
  14.     virtual void show() = 0;
  15. };
  17. class ProductA : public Product
  18. {
  19. public:
  20.     void show(void)
  21.     {
  22.         std::cout << "I'm ProductA" << std::endl;
  23.     }
  24. };
  26. class ProductB : public Product
  27. {
  28. public:
  29.     void show(void)
  30.     {
  31.         std::cout << "I'm ProductB" << std::endl;
  32.     }
  33. };
  35. class ProductC : public Product
  36. {
  37. public:
  38.     void show(void)
  39.     {
  40.         std::cout << "I'm ProductC" << std::endl;
  41.     }
  42. };
  44. // Here is the Factory class
  45. class Factory
  46. {
  47. public:
  48.     Product* CreateProduct(PRODUCTTYPE type)
  49.     {
  50.         switch (type)
  51.         {
  52.             case TypeA:
  53.                 return new ProductA;
  54.                 
  55.             case TypeB:
  56.                 return new ProductB;
  57.                 
  58.             case TypeC:
  59.                 return new ProductC;
  60.                 
  61.             default:
  62.                 return NULL;
  63.         }
  64.     }
  65. };
  67. int main(int argc, char *argv[])
  68. {
  69.     // First, create a factory object
  70.     Factory *ProductFactory = new Factory();
  71.     Product *productObjA = ProductFactory->CreateProduct(TypeA);
  72.     if (productObjA != NULL)
  73.         productObjA->show();
  74.     
  75.     Product *productObjB = ProductFactory->CreateProduct(TypeB);
  76.     if (productObjB != NULL)
  77.         productObjB->show();
  78.     
  79.     Product *productObjC = ProductFactory->CreateProduct(TypeC);
  80.     if (productObjC != NULL)
  81.         productObjC->show();
  82.     
  83.     delete ProductFactory;
  84.     delete productObjA;
  85.     delete productObjB;
  86.     delete productObjC;
  87.     
  88.     return 0;
  89. }

      
      

     
     
12 模板方法模式
12.1 问题
全部由纯虚函数构成的抽象类称为纯抽象类或接口。面向抽象编程，使得所有基于接口编写的代码，在子类被更替后，无需做任何修改或只需做很少的修改，就能在新子类上正确运行。
12.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：模板方法模式
代码如下：

     
     

      
      

       
       

         
         
  1. #include <iostream>
  3. class Abstract
  4. {
  5. protected:
  6.     virtual void PrimitiveOperation1() = 0;
  7.     virtual void PrimitiveOperation2() = 0;
  8. public:
  9.     void TemplateMethod()
  10.     {
  11.         std::cout << "TemplateMethod" << std::endl;
  12.         PrimitiveOperation1();
  13.         PrimitiveOperation2();
  14.     }
  15. };
  17. class ConcreteA : public Abstract
  18. {
  19. protected:
  20.     virtual void PrimitiveOperation1()
  21.     {
  22.         std::cout << "ConcreteA Operation1" << std::endl;
  23.     }
  24.     virtual void PrimitiveOperation2()
  25.     {
  26.         std::cout << "ConcreteA Operation2" << std::endl;
  27.     }
  28. };
  30. class ConcreteB : public Abstract
  31. {
  32. protected:
  33.     virtual void PrimitiveOperation1()
  34.     {
  35.         std::cout << "ConcreteB Operation1" << std::endl;
  36.     }
  37.     virtual void PrimitiveOperation2()
  38.     {
  39.         std::cout << "ConcreteB Operation2" << std::endl;
  40.     }
  41. };
  43. int main()
  44. {
  45.     Abstract *pAbstractA = new ConcreteA;
  46.     pAbstractA->TemplateMethod();
  47.     
  48.     Abstract *pAbstractB = new ConcreteB;
  49.     pAbstractB->TemplateMethod();
  50.     
  51.     delete pAbstractA;
  52.     delete pAbstractB;
  53. }

      
      

     
     
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1. class Abstract
  2. {
  3. protected:
  4.     virtual void PrimitiveOperation1() = 0;
  5.     virtual void PrimitiveOperation2() = 0;
  6. public:
  7.     void TemplateMethod()
  8.     {
  9.         std::cout << "TemplateMethod" << std::endl;
  10.         PrimitiveOperation1();
  11.         PrimitiveOperation2();
  12.     }
  13. };

      
      

     
     
定义了抽象模板类Abstract。在该类中，定义两个抽象的原语操作纯虚函数PrimitiveOperation1和纯虚函数PrimitiveOperation2，用这两个原语操作定义一个抽象算法的两个步骤。在该类中还定义了一个模板成员函数TemplateMethod负责整合两个原语操作及其它一些操作，形成一个不变的算法流程。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1. class ConcreteA : public Abstract
  2. {
  3. protected:
  4.     virtual void PrimitiveOperation1()
  5.     {
  6.         std::cout << "ConcreteA Operation1" << std::endl;
  7.     }
  8.     virtual void PrimitiveOperation2()
  9.     {
  10.         std::cout << "ConcreteA Operation2" << std::endl;
  11.     }
  12. };
  14. class ConcreteB : public Abstract
  15. {
  16. protected:
  17.     virtual void PrimitiveOperation1()
  18.     {
  19.         std::cout << "ConcreteB Operation1" << std::endl;
  20.     }
  21.     virtual void PrimitiveOperation2()
  22.     {
  23.         std::cout << "ConcreteB Operation2" << std::endl;
  24.     }
  25. };

      
      

     
     
定义了两个实体类，在这两个实体类中，各自实现两个具体的原语操作，完成各自实体中的具体算法的各步骤的具体操作。这样如果再有其它的具体算法，只需要再定义一个实体类，实现具体的原语操作即可。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     Abstract *pAbstractA = new ConcreteA;
  2.     pAbstractA->TemplateMethod();

      
      

     
     
在主程序中，用抽象模板类Abstract的指针指向实体类ConcreteA，完成一个具体的算法。
12.3 完整代码
本案例的完整代码如下所示：

     
     

      
      

       
       

         
         
  1. #include <iostream>
  3. class Abstract
  4. {
  5. protected:
  6.     virtual void PrimitiveOperation1() = 0;
  7.     virtual void PrimitiveOperation2() = 0;
  8. public:
  9.     void TemplateMethod()
  10.     {
  11.         std::cout << "TemplateMethod" << std::endl;
  12.         PrimitiveOperation1();
  13.         PrimitiveOperation2();
  14.     }
  15. };
  17. class ConcreteA : public Abstract
  18. {
  19. protected:
  20.     virtual void PrimitiveOperation1()
  21.     {
  22.         std::cout << "ConcreteA Operation1" << std::endl;
  23.     }
  24.     virtual void PrimitiveOperation2()
  25.     {
  26.         std::cout << "ConcreteA Operation2" << std::endl;
  27.     }
  28. };
  30. class ConcreteB : public Abstract
  31. {
  32. protected:
  33.     virtual void PrimitiveOperation1()
  34.     {
  35.         std::cout << "ConcreteB Operation1" << std::endl;
  36.     }
  37.     virtual void PrimitiveOperation2()
  38.     {
  39.         std::cout << "ConcreteB Operation2" << std::endl;
  40.     }
  41. };
  43. int main()
  44. {
  45.     Abstract *pAbstractA = new ConcreteA;
  46.     pAbstractA->TemplateMethod();
  47.     
  48.     Abstract *pAbstractB = new ConcreteB;
  49.     pAbstractB->TemplateMethod();
  50.     
  51.     delete pAbstractA;
  52.     delete pAbstractB;
  53. }

      
      

     
     
13 单继承虚表模型
13.1 问题
编译器会为每个包含虚函数的类生成一张虚函数表，即存放每个虚函数地址的函数指针数组，简称虚表(vtbl)。
13.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：单继承虚表模型
代码如下：

     
     

      
      

       
       

         
         
  1. #include <iostream>
  3. class Base
  4. {
  5. public:
  6.     virtual int f1 (void)
  7.     {
  8.         std::cout << "Base f1" << std::endl;
  9.         return 0;
  10.     }
  11.     virtual void f2 (int i)
  12.     {
  13.         std::cout << "Base f2" << std::endl;
  14.     }
  15.     virtual int f3 (int i)
  16.     {
  17.         std::cout << "Base f3" << std::endl;
  18.         return 0;
  19.     }
  20. };
  22. class Derived : public Base
  23. {
  24. public:
  25.     int f1 (void)
  26.     {
  27.         std::cout << "Derived f1" << std::endl;
  28.         return 0;
  29.     }
  30.     int f3 (int i)
  31.     {
  32.         std::cout << "Derived f3" << std::endl;
  33.         return 0;
  34.     }
  35.     virtual void f4 (void)
  36.     {
  37.         std::cout << "Derived f4" << std::endl;
  38.     }
  39. };
  41. int main()
  42. {
  43.     Base *b = new Base;
  44.     b->f3(10);
  45.     delete b;
  46.     
  47.     b = new Derived;
  48.     b->f3(20);
  49.     delete b;
  50. }

      
      

     
     
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1. class Base
  2. {
  3. public:
  4.     virtual int f1 (void)
  5.     {
  6.         std::cout << "Base f1" << std::endl;
  7.         return 0;
  8.     }
  9.     virtual void f2 (int i)
  10.     {
  11.         std::cout << "Base f2" << std::endl;
  12.     }
  13.     virtual int f3 (int i)
  14.     {
  15.         std::cout << "Base f3" << std::endl;
  16.         return 0;
  17.     }
  18. };

      
      

     
     
定义了一个类Base，该类中含有三个虚函数。编译器会为类Base生成一张虚函数表，该表是用于存放每个虚函数地址的函数指针数组，简称虚表(vtbl)，每个虚函数对应一个虚函数表中的数组元素。即vtbl[0]->f1，vtbl[1]->f2，vtbl[2]->f3。
除了为类Base生成虚函数表以外，编译器还会为类Base增加一个隐式的成员变量，通常在该类实例化对象的起始位置，用于存放虚函数表的首地址，该变量被称为虚函数表指针，简称虚指针(vptr)。即vptr = &vtbl[0]。
这样，主程序中以下语句：

     
     

      
      

       
       

         
         
  1.     Base *b = new Base;
  2.     b->f3(10);

      
      

     
     
相当于：

     
     

      
      

       
       

         
         
  1.     Base *b = new Base;
  2.     b->vptr[2](10);

      
      

     
     
虚表是一个类一张，而不是一个对象一张，同一个类的多个对象，通过各自的虚指针，共享同一张虚表。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1. class Derived : public Base
  2. {
  3. public:
  4.     int f1 (void)
  5.     {
  6.         std::cout << "Derived f1" << std::endl;
  7.         return 0;
  8.     }
  9.     int f3 (int i)
  10.     {
  11.         std::cout << "Derived f3" << std::endl;
  12.         return 0;
  13.     }
  14.     virtual void f4 (void)
  15.     {
  16.         std::cout << "Derived f4" << std::endl;
  17.     }
  18. };

      
      

     
     
定义了子类Derived，并且在子类Derived中覆盖了基类Base的f1和f3，继承了基类Base的f2，增加了自己的f4，编译器同样会为子类生成一张专属于它的虚表。指向子类Derived虚表的虚指针就存放在子类对象的基类子对象中，通常还是在起始位置。
这样，主程序中以下语句：

     
     

      
      

       
       

         
         
  1.     b = new Derived;
  2.     b->f3(20);

      
      

     
     
相当于：

     
     

      
      

       
       

         
         
  1.     b = new Derived;
  2.     b->vptr[2](20);

      
      

     
     
此时vptr[2]中存放的是子类Derived中覆盖基类Base的f3，而这就是所谓的多态。
13.3 完整代码
本案例的完整代码如下所示：

     
     

      
      

       
       

         
         
  1. #include <iostream>
  3. class Base
  4. {
  5. public:
  6.     virtual int f1 (void)
  7.     {
  8.         std::cout << "Base f1" << std::endl;
  9.         return 0;
  10.     }
  11.     virtual void f2 (int i)
  12.     {
  13.         std::cout << "Base f2" << std::endl;
  14.     }
  15.     virtual int f3 (int i)
  16.     {
  17.         std::cout << "Base f3" << std::endl;
  18.         return 0;
  19.     }
  20. };
  22. class Derived : public Base
  23. {
  24. public:
  25.     int f1 (void)
  26.     {
  27.         std::cout << "Derived f1" << std::endl;
  28.         return 0;
  29.     }
  30.     int f3 (int i)
  31.     {
  32.         std::cout << "Derived f3" << std::endl;
  33.         return 0;
  34.     }
  35.     virtual void f4 (void)
  36.     {
  37.         std::cout << "Derived f4" << std::endl;
  38.     }
  39. };
  41. int main()
  42. {
  43.     Base *b = new Base;
  44.     b->f3(10);
  45.     delete b;
  46.     
  47.     b = new Derived;
  48.     b->f3(20);
  49.     delete b;
  50. }

      
      

     
     
14 动态类型转换
14.1 问题
动态类型转换(dynamic_cast)用于将基类类型的指针或引用转换为其子类类型的指针或引用，前提是子类必须从基类多态继承，即基类包含至少一个虚函数
14.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：动态类型转换
代码如下：

     
     

      
      

       
       

         
         
  1. #include <iostream>
  3. class Base
  4. {
  5. public:
  6.     virtual int f1 (void)
  7.     {
  8.         std::cout << "Base f1" << std::endl;
  9.         return 0;
  10.     }
  11. };
  13. class Derived : public Base
  14. {
  15. public:
  16.     int f1 (void)
  17.     {
  18.         std::cout << "Derived f1" << std::endl;
  19.         return 0;
  20.     }
  21. };
  23. int main()
  24. {
  25.     Derived d;
  26.     Base* pa = &d;
  27.     Derived* pb = dynamic_cast<Derived*> (pa);
  28.     if (pb == NULL)
  29.         std::cout << "转换失败！" << std::endl;
  31.     Base& ra = d;
  32.     try {
  33.         Derived& rb = dynamic_cast<Derived&> (ra);
  34.     }
  35.     catch (std::bad_cast& ex)
  36.     {
  37.         std::cout << "转换失败！" << std::endl;
  38.     }
  40.     Derived b = dynamic_cast<Derived> (*pa);
  41.     
  42.     return 0;
  43. }

      
      

     
     
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     Derived d;
  2.     Base* pa = &d;
  3.     Derived* pb = dynamic_cast<Derived*> (pa);

      
      

     
     
应用动态类型转换，将基类Base类型的指针转换为其子类Derived类型的指针。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     if (pb == NULL)
  2.         std::cout << "转换失败！" << std::endl;

      
      

     
     
针对指针的动态类型转换，以返回空指针(NULL)表示失败。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     Base& ra = d;
  2.     try {
  3.         Derived& rb = dynamic_cast<Derived&> (ra);
  4.     }

      
      

     
     
应用动态类型转换，将基类Base类型的引用转换为其子类Derived类型的引用。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     Base& ra = d;
  2.     try {
  3.         Derived& rb = dynamic_cast<Derived&> (ra);
  4.     }
  5.     catch (std::bad_cast& ex)
  6.     {
  7.         std::cout << "转换失败！" << std::endl;
  8.     }

      
      

     
     
针对引用的动态类型转换，以抛出bad_cast异常表示失败。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     Derived b = dynamic_cast<Derived> (*pa);

      
      

     
     
不是针对指针或引用做的动态类型转换，编译错误。另外，要注意，转换目标类型和源类型之间不具有多态继承性也会发生编译错误。转换源类型的目标对象非目标类型会发生运行错误。
14.3 完整代码
本案例的完整代码如下所示：

     
     

      
      

       
       

         
         
  1. #include <iostream>
  3. class Base
  4. {
  5. public:
  6.     virtual int f1 (void)
  7.     {
  8.         std::cout << "Base f1" << std::endl;
  9.         return 0;
  10.     }
  11. };
  13. class Derived : public Base
  14. {
  15. public:
  16.     int f1 (void)
  17.     {
  18.         std::cout << "Derived f1" << std::endl;
  19.         return 0;
  20.     }
  21. };
  23. int main()
  24. {
  25.     Derived d;
  26.     Base* pa = &d;
  27.     Derived* pb = dynamic_cast<Derived*> (pa);
  28.     if (pb == NULL)
  29.         std::cout << "转换失败！" << std::endl;
  31.     Base& ra = d;
  32.     try {
  33.         Derived& rb = dynamic_cast<Derived&> (ra);
  34.     }
  35.     catch (std::bad_cast& ex)
  36.     {
  37.         std::cout << "转换失败！" << std::endl;
  38.     }
  40.     Derived b = dynamic_cast<Derived> (*pa);
  42.     
  43.     return 0;
  44. }

      
      

     
     
15 类型信息
15.1 问题
typeid操作符既可用于类型也可用于对象，用于返回类型信息，即类typeinfo对象的常引用。类typeinfo中含所有一个成员函数name，通过它可以得到类型名。
15.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：类型信息
代码如下：

     
     

      
      

       
       

         
         
  1. #include <iostream>
  3. class A
  4. {
  5. };
  7. class B : public A
  8. {
  9. public:
  10.     virtual void foo (void)
  11.     {
  12.     }
  13. };
  15. class C : public B
  16. {
  17. };
  19. int main()
  20. {
  21.     int x;
  22.     int * px;
  23.     std::cout << "int is: " << typeid(int).name() << std::endl;
  24.     std::cout << "  x is: " << typeid(x).name() << std::endl;
  25.     std::cout << " px is: " << typeid(px).name() << std::endl;
  26.     std::cout << "*px is: " << typeid(*px).name() << std::endl;
  27.     
  28.     C c;
  29.     A& a = c;
  30.     std::cout << typeid (a).name () << std::endl;
  31.     B& b = c;
  32.     std::cout << typeid (b).name () << std::endl;
  33.     
  34.     return 0;
  35. }

      
      

     
     
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     int x;
  2.     int * px;
  3.     std::cout << "int is: " << typeid(int).name() << std::endl;
  4.     std::cout << "  x is: " << typeid(x).name() << std::endl;
  5.     std::cout << " px is: " << typeid(px).name() << std::endl;
  6.     std::cout << "*px is: " << typeid(*px).name() << std::endl;

      
      

     
     
使用typeid获取指定目标的类型信息。如：

     
     

      
      

       
       

         
         
  1.     std::cout << "int is: " << typeid(int).name() << std::endl;

      
      

     
     
的输出结果为：int is: i。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     C c;
  2.     A& a = c;
  3.     std::cout << typeid (a).name () << std::endl;

      
      

     
     
当typeid作用于基类A类型的引用的目标c时，若基类A中不包含任何虚函数，则该操作符所返回的类型信息由引用A本身的类型决定，即返回的是类A的类名A。
上述代码中，以下代码：

     
     

      
      

       
       

         
         
  1.     B& b = c;
  2.     std::cout << typeid (b).name () << std::endl;

      
      

     
     
当typeid作用于基类B类型的引用的目标c时，若基类包含至少一个虚函数，即存在多态继承，该操作符所返回的类型信息由该引用的实际目标对象的类型决定，即返回的是类C的类名C。
15.3 完整代码
本案例的完整代码如下所示：

     
     

      
      

       
       

         
         
  1. #include <iostream>
  3. class A
  4. {
  5. };
  7. class B : public A
  8. {
  9. public:
  10.     virtual void foo (void)
  11.     {
  12.     }
  13. };
  15. class C : public B
  16. {
  17. };
  19. int main()
  20. {
  21.     int x;
  22.     int * px;
  23.     std::cout << "int is: " << typeid(int).name() << std::endl;
  24.     std::cout << "  x is: " << typeid(x).name() << std::endl;
  25.     std::cout << " px is: " << typeid(px).name() << std::endl;
  26.     std::cout << "*px is: " << typeid(*px).name() << std::endl;
  27.     
  28.     C c;
  29.     A& a = c;
  30.     std::cout << typeid (a).name () << std::endl;
  31.     B& b = c;
  32.     std::cout << typeid (b).name () << std::endl;
  33.     
  34.     return 0;
  35. }
opera92
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式之适配器模式
01-20
买笔记本电脑，买手机时，都有一个电源适配器，电源适配器又叫外置电源，是小型便携式电子设备及电子电器的供电电压变换设备，常见于手机，笔记本电脑上。它的作用是将家里的220V高电压转换成这些电子产品能工作的5V...
Qt之美（一）：d指针/p指针详解
wangxiaohigh
11-16 1781
Translated by mznewfacer2011.11.16 首先，看了Xizhi Zhu 的这篇Qt之美（一）：D指针/私有实现，对于很多批评不美的同路人，暂且不去评论，只是想支持一下Xizhi Zhu，在引用一下Jerry Sun的话，“C++需要宏定义就像需要设计模式一样。也许你不知道，宏是图灵完全（turing complete）的，至少LISP下是这样，C/C++需要宏，几乎...
C++ 常见设计模式总结
qq_41952309的博客
08-22 1668
c++ 常见设计模式整理。
C++ 常见设计模式
HYB3701的博客
04-25 7819
一、定义：定义一系列算法(将算法定义为虚函数，子类重写它），将它们封装起来，并使他们可互相替换（变化）。 二、应用场景：在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不使用的算法也是一个性能负担（例如if/else条件判断语句有很多判断语句不会被执行）。 三、解决什么问题：在运行时根据需要透明地更改对象的算法；将算法与对象本身解耦。 原始代码设计（伪代码）： enum TaxBase { CN_Tax, ...
C++几种常用设计模式
qq_46423987的博客
09-05 1万+
设计模式
C++常见设计模式之组合模式
scarificed的博客
11-15 1645
1、组合模式（Composite）： 组合模式是为了解决整体和部分的一致对待的问题而产生的，要求这个整体与部分有一致的行为或操作，部分和整体都继承于一个公共的抽象类（公共操作），这样外部使用他们的时候是一致的 ，不管是对于整体还是部分使用一个方法即可遍历整体中所有的部分。上面说的可能有一些难懂，我们举一个例子。 有一家北京的公司在北京有自己的总部，还有旗下的很多个部门，这家北京的公司发展的很好，它在上海和杭州等地都有自己的分支公司，同样这些在其他地方的分公司旗下也有很多个部门，如果分支公司发展的好，同样也会
C++中常见的三种设计模式
qq_38917783的博客
04-25 2133
学习C++已经很长时间了，但是学过之后就没有在复习过，在近期的面试过程中总是因为一些基础知识掌握不牢固导致面试过不了，于是我又重新复习了一下基础知识，顺便整理一下知识点，让自己的基础更牢固一些。 今天主要总结的知识点是关于C++中常用的设计模式中的三种，分别是单例模式、工厂模式和观察者模式。 1、单例模式 其作用是保证一个类只有一个实例，并且提供一个访问它的全局访问点，使得系统中只有唯一的一...
C++常用的11种设计模式解释及示例
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
02-06 4827
c++常用的设计模式包括单例模式、工厂模式、抽象工厂模式、适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式、观察者模式和命令模式等。 使用设计模式的好处：提高代码的可读性和可维护性；将常见的设计问题隔离程序的业务逻辑；重用已有的实现；消除重复代码；消除手动调整代码以达到正确逻辑的所有痛苦。
设计模式之代理模式(C++)
热门推荐
翟天保的博客
04-04 2万+
介绍设计模式之代理模式
C++常用的11种设计模式
qq_43920560的博客
03-08 1万+
这里写目录标题工厂模式单例模式（懒汉式、饿汉式）适配器模式外观模式代理模式包装模式（装饰器模式）桥接模式模板方法模式策略模式观察者模式责任链模式 工厂模式 定义：将工厂变成一个抽象类，在里面定义一个纯虚函数，具体生成什么产品交给子类继承去决定（抽象产品类-》具体产品类-》抽象工厂类-》具体工厂类） * 作用：封装对象的创建，解决new解耦的问题 * 适用场景：用来生产同一等级结构中的固定产品。（支持增加任意产品） * 实例：水果例子；数据库访问； * 优点：当系统扩展需要添加新的产品对象时，仅仅需要添加一个
C++常见设计模式——模板模式
hang_1994的博客
03-06 816
设计模式是对设计原则的具体化。用江湖话说就是武林秘籍，总结出来的一些固定套路，可以帮助有根基的程序员迅速打通任督二脉，从此做什么都特别快。常用的模式及其场景如下 C++常见设计模式——模板模式 模板模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 当多个类有相同的方法，并且逻辑相同，只是细节上有差异时，可以考虑使用...
C++开发设计模式.zip
04-11
对C++设计模式进行深入讲解，剖析16种常见模式包括工厂模式、策略模式、适配器模式、单例模式、原型模式、模板方法模式、建造者模式、观察者模式等
C++和java设计模式之单例模式
08-31
主要为大家详细介绍了C++和java设计模式之单例模式的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++常见设计模式的解析和实现+源码解析.rar
04-30
常见设计模式的解析和实现(C++)，真的很经典，我也在学 常见设计模式的解析和实现(C++)之一-Factory模式 常见设计模式的解析和实现(C++)之二-Abstract Factory模式 常见设计模式的解析和实现(C++)之三-Builder模式 ...
C++常见设计模式的解析和实现+源码解析
03-22
该书形象生动地介绍了23种常用设计模式，并提供了C++源码，可以让读者对设计模式有更充分的了解。
node-v4.2.2-headers.tar.xz
05-21
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
独栋别墅图纸D020-两层-10.00&11.00米- 施工图.dwg
05-21
独栋别墅图纸D020-两层-10.00&11.00米- 施工图.dwg
ndnav主题1.1-haiyong.zip
05-21
内容概要： "ndnav主题1.1-haiyong.zip"是一个针对特定导航需求设计的主题包，提供了一套优化的界面元素和布局，旨在增强用户体验和导航效率。这个主题可能包含了图标、色彩方案、字体样式等视觉元素的自定义，以及可能的操作流程优化，确保用户能够快速找到所需信息。 适用人群： 此主题适合需要高效导航解决方案的用户群体，比如专业领域的工作者、研究人员或是对特定领域有深入了解并追求高效率的信息检索者。它也可能适合那些喜欢定制化界面并希望根据个人喜好或工作需求调整导航工具外观和功能的用户。 使用场景及目标： 该主题可用于多种场合，如图书馆、研究机构、学术会议、企业内部信息系统等，任何需要快速而准确导航大量信息资源的环境都会受益。其目标是减少用户在查找和访问信息时的认知负担，通过直观的设计和布局简化用户路径，从而提高工作效率和满意度。 其他说明： 由于没有具体的文件内容，无法提供更详细的功能描述。不过，一般来说，此类主题包的安装和使用可能需要一定的技术知识，用户在安装前应确保理解如何应用主题，并遵循相关的安装指南。同时，用户也应该注意检查主题包的兼容性，确保它能够与现有的导航系统无缝协作。
grpcio-1.12.0-cp35-cp35m-manylinux1_i686.whl
最新发布
05-21
Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
c++常见的设计模式
10-17
常见的 C++ 设计模式有以下几种： 1. 工厂模式（Factory Pattern）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 2. 单例模式（Singleton Pattern）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。 3. 观察者模式（Observer Pattern）：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有依赖者都会收到通知并更新。 4. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 5. 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式比生成子类更为灵活。 6. 策略模式（Strategy Pattern）：定义一系列算法，将每个算法封装起来，并使它们之间可以互换。 7. 模板方法模式（Template Method Pattern）：定义一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 8. 建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 9. 迭代器模式（Iterator Pattern）：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。 10. 外观模式（Facade Pattern）：为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值