devbox
信息技术墨韵书生
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

c++ 常用总结（三）_std::shared_ptr

作者：信息技术墨韵书生 | 2024-01-31 18:46:59

赞

踩

std::shared_ptr

1.设计模式 

 GitHub - FengJungle/DesignPattern: Design pattern demo code

（一） 

① 简单工厂模式

 再不学简单工厂模式，就真的要去工厂搬砖啦~_冯Jungle的博客-CSDN博客

通过以下的例子可见，只需要提供产品名称作为参数，传入工厂的方法中，即可得到对应产品。抽象产品类中并没有提供公共方法的实现，而是在各个具体产品类中根据各自产品情况实现。

当然，简单工厂模式存在明显的不足。假设有一天Jungle想玩网球了，该怎么办呢？你肯定会说，这还不容易吗？再从抽象产品类派生出一个Tennis类，并在工厂类的getSportProduct方法中增加“productName == "Tennis”的条件分支即可。的确如此，但是这明显违背了开闭原则（对扩展开放，对修改关闭），即在扩展功能时修改了已有的代码。另一方面，简单工厂模式所有的判断逻辑都在工厂类中实现，一旦工厂类设计故障，则整个系统都受之影响！

例1

SimpleFactory.h

  1. #ifndef _SIMPLE_FACTORY_
  2. #define _SIMPLE_FACTORY_
  3.  
  4. #include <iostream>
  5.  
  6. // 抽象类
  7. class AbstractSportProduct{
  8. public:
  9.     virtual void printName() = 0;
  10.     virtual void play() = 0;
  11. };
  12.  
  13. class Basketball : public AbstractSportProduct{
  14. public:
  15.     void printName(){std::cout << "Jungle get Basketball\n";}
  16.     void play(){std::cout << "Jungle play Basketball\n";}
  17. };
  18.  
  19. class Football : public AbstractSportProduct{
  20. public:
  21.     Football(){
  22. 		printName();
  23. 		play();
  24. 	}
  25.     void printName(){std::cout << "Jungle get Football\n";}
  26.     void play(){std::cout << "Jungle play Football\n";}
  27. };
  28.  
  29. class Volleyball : public AbstractSportProduct{
  30. public:
  31.     void printName(){std::cout << "Jungle get Volleyball\n";}
  32.     void play(){std::cout << "Jungle play Volleyball\n";}
  33. };
  34.  
  35. class Factory{
  36. public:
  37.     std::shared_ptr<AbstractSportProduct> getSportProduct(std::string productName){
  38.         std::shared_ptr<AbstractSportProduct> pro;
  39.         if(productName == "Basketball"){
  40.             pro = std::make_shared<Basketball>();
  41.         }else if (productName == "Football"){
  42.             pro = std::make_shared<Football>();
  43.         }else if (productName == "Volleyball"){
  44.             pro = std::make_shared<Volleyball>();
  45.         }
  46.         return pro;
  47.     }
  48. };
  49.  
  50. #endif

main.cpp

  1. #include <iostream>
  2. #include "SimpleFactory.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<Factory> f = std::make_shared<Factory>();
  6.     std::shared_ptr<AbstractSportProduct> pro = f->getSportProduct("Basketball");
  7.     pro->printName();
  8.     pro->play();
  9.  
  10.     std::cout << "-------------------------\n";
  11.     pro = f->getSportProduct("Football");
  12.  
  13.     std::cout << "-------------------------\n";
  14.     pro = f->getSportProduct("Volleyball");
  15.     pro->printName();
  16.     pro->play();
  17.  
  18.     return 0;
  19. }

② 工厂模式

如果Jungle想玩网球（Tennis），只需要增加一个棒球工厂（TennisFacory），然后在客户端代码中修改具体工厂类的类名，而原有的类的代码无需修改。由此可看到，相较简单工厂模式，工厂方法模式更加符合开闭原则。工厂方法是使用频率最高的设计模式之一，是很多开源框架和API类库的核心模式。

例1

FactoryMethod.h

  1. #ifndef __FACTORY_METHOD__
  2. #define __FACTORY_METHOD__
  3.  
  4. #include <iostream>
  5.  
  6. // 抽象产品类
  7. class AbstractSportProduct{
  8. public:
  9. 	virtual void printName() = 0;
  10. 	virtual void play() = 0;
  11. };
  12.  
  13. class Basketball :public AbstractSportProduct{
  14. public:
  15. 	void printName(){std::cout << "Jungle get Basketball\n";}
  16. 	void play(){std::cout << "Jungle play Basketball\n";}
  17. };
  18.  
  19. class Football :public AbstractSportProduct{
  20. public:
  21.     Football(){
  22.         printName();
  23.         play();
  24.     }
  25. 	void printName(){std::cout << "Jungle get Football\n";}
  26. 	void play(){std::cout << "Jungle play Football\n";}
  27. };
  28.  
  29. class Volleyball :public AbstractSportProduct{
  30. public:
  31. 	void printName(){std::cout << "Jungle get Volleyball\n";}
  32. 	void play(){std::cout << "Jungle play Volleyball\n";}
  33. };
  34.  
  35. // 抽象工厂类
  36. class AbstractFactory{
  37. public:
  38.     virtual std::shared_ptr<AbstractSportProduct> getSportProduct() = 0;
  39. };
  40.  
  41. class BasketballFactory : public AbstractFactory{
  42. public:
  43.     std::shared_ptr<AbstractSportProduct> getSportProduct() {
  44.         return std::make_shared<Basketball>();
  45.     }
  46. };
  47.  
  48. class FootballFactory : public AbstractFactory{
  49. public:
  50.     std::shared_ptr<AbstractSportProduct> getSportProduct() {
  51.         return std::make_shared<Football>();
  52.     }
  53. };
  54.  
  55. class VolleyballFactory : public AbstractFactory{
  56. public:
  57.     std::shared_ptr<AbstractSportProduct> getSportProduct() {
  58.         return std::make_shared<Volleyball>();
  59.     }
  60. };
  61.  
  62. #endif

main.cpp

  1. #include <iostream>
  2. #include "FactoryMethod.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<BasketballFactory> f = std::make_shared<BasketballFactory>();
  6.     std::shared_ptr<AbstractSportProduct> pro = f->getSportProduct();
  7.     pro->printName();
  8.     pro->play();
  9.  
  10.     std::cout << "------------------------------\n";
  11.     std::shared_ptr<FootballFactory> f1 = std::make_shared<FootballFactory>();
  12.     pro = f1->getSportProduct();
  13.  
  14.     std::cout << "------------------------------\n";
  15.     std::shared_ptr<VolleyballFactory> f2 = std::make_shared<VolleyballFactory>();
  16.     pro = f2->getSportProduct();
  17.     pro->printName();
  18.     pro->play();
  19.  
  20.     return 0;
  21. }

③ 抽象工厂模式

回顾之前的设计模式，简单工厂模式所有逻辑都封装在工厂类中，工厂根据客户提供的产品名字创建对应产品的对象实例；工厂方法模式将产品的创建过程放到了具体工厂类中，每一个工厂可以创建一个具体产品，由此可能会创建许多工厂类。很多时候，一个工厂不只是生产一种产品，而是生产一类产品，比如一个体育用品工厂，可以生产篮球、足球、排球等多种产品。此时我们可以把这些相关的产品归纳为一个“产品族”，由同一个工厂来生产，这即是Jungle今天要学习的抽象工厂模式。

例1

AbstractFactory.h

  1. #ifndef __ABSTRACT_FACTORY__
  2. #define __ABSTRACT_FACTORY__
  3.  
  4. #include <iostream>
  5.  
  6. // 抽象球类
  7. class AbstractBall{
  8. public:
  9.     virtual void play() = 0;
  10. };
  11.  
  12. class Basketball : public AbstractBall{
  13. public:
  14.     void play() {std::cout << "Jungle play Basketball\n";}
  15. };
  16.  
  17. class Football : public AbstractBall{
  18. public:
  19.     void play() {std::cout << "Jungle play Football\n";}
  20. };
  21.  
  22. // 抽象衬衫类
  23. class AbstractShirt{
  24. public:
  25.     virtual void wearShirt() = 0;
  26. };
  27.  
  28. class BasketballShirt : public AbstractShirt{
  29. public:
  30.     void wearShirt() {std::cout << "Jungle wear Basketball Shirt\n";}
  31. };
  32.  
  33. class FootballShirt : public AbstractShirt{
  34. public:
  35.     void wearShirt() {std::cout << "Jungle wear Football Shirt\n";}
  36. };
  37.  
  38. // 抽象工厂类
  39. class AbstractFactory{
  40. public:
  41.     virtual std::shared_ptr<AbstractBall> getBall() = 0;
  42.     virtual std::shared_ptr<AbstractShirt> getShirt() = 0;
  43. };
  44.  
  45. class BasketballFactory : public AbstractFactory{
  46. public:
  47.     std::shared_ptr<AbstractBall> getBall(){
  48.         std::cout << "Jungle get Basketball\n";
  49.         return std::make_shared<Basketball>();
  50.     }
  51.     std::shared_ptr<AbstractShirt> getShirt(){
  52.         std::cout << "Jungle get Basketball Shirt\n";
  53.         return std::make_shared<BasketballShirt>();
  54.     }
  55. };
  56.  
  57. class FootballFactory : public AbstractFactory{
  58. public:
  59.     std::shared_ptr<AbstractBall> getBall(){
  60.         std::cout << "Jungle get Football\n";
  61.         return std::make_shared<Football>();
  62.     }
  63.     std::shared_ptr<AbstractShirt> getShirt(){
  64.         std::cout << "Jungle get Football Shirt\n";
  65.         return std::make_shared<FootballShirt>();
  66.     }
  67. };
  68.  
  69. #endif

main.cpp

  1. #include <iostream>
  2. #include "AbstractFactory.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<BasketballFactory> f = std::make_shared<BasketballFactory>();
  6.     std::shared_ptr<AbstractBall> ab = f->getBall();    
  7.     std::shared_ptr<AbstractShirt> as = f->getShirt();
  8.     ab->play();
  9.     as->wearShirt();
  10.  
  11.     std::cout << "---------------------------------\n";
  12.     std::shared_ptr<FootballFactory> f1 = std::make_shared<FootballFactory>();
  13.     ab = f1->getBall();    
  14.     as = f1->getShirt();
  15.     ab->play();
  16.     as->wearShirt();
  17.  
  18.     return 0;
  19. }

④ 建造者模式

例1

BuilderPattern.h

  1. #ifndef __BUILDER_PATTERN__
  2. #define __BUILDER_PATTERN__
  3.  
  4. #include <iostream>
  5.  
  6. // 产品类
  7. class House{
  8. public:
  9.     void setFloor(std::string iFloor){
  10.         this->floor = iFloor;
  11.     }
  12.  
  13.     void setWall(std::string iWall){
  14.         this->wall = iWall;
  15.     }
  16.  
  17.     void setRoof(std::string iRoof){
  18.         this->roof = iRoof;
  19.     }
  20.  
  21.     void printfHouseInfo() {
  22.         std::cout << "floor: " << floor << "\n";
  23.         std::cout << "wall: "  << wall  << "\n";
  24.         std::cout << "roof: "  << roof  << "\n";
  25.     }
  26.  
  27. private:
  28.     std::string floor;
  29.     std::string wall;
  30.     std::string roof;
  31. };
  32.  
  33. // 抽象建造者
  34. class AbstractBuilder{
  35. public:
  36.     AbstractBuilder(){house = std::make_shared<House>();}
  37.  
  38.     virtual void buildFloor() = 0;
  39.     virtual void buildWall() = 0;
  40.     virtual void buildRoof() = 0;
  41.     virtual std::shared_ptr<House> getHouse() = 0;
  42.     std::shared_ptr<House> house;
  43. };
  44.  
  45. // 具体建造者A
  46. class ConcreteBuilderA : public AbstractBuilder{
  47. public:
  48.     void buildFloor() {
  49.         house->setFloor("Floor_A");
  50.     }
  51.     void buildWall(){
  52.         house->setWall("Wall_A");
  53.     }
  54.     void buildRoof(){
  55.         house->setRoof("Roof_A");
  56.     }
  57.     std::shared_ptr<House> getHouse(){
  58.         return house;
  59.     }
  60. };
  61.  
  62. // 具体建造者B
  63. class ConcreteBuilderB : public AbstractBuilder{
  64. public:
  65.     void buildFloor() {        
  66.         house->setFloor("Floor_B");
  67.     }
  68.     void buildWall(){        
  69.         house->setWall("Wall_B");
  70.     }
  71.     void buildRoof(){        
  72.         house->setRoof("Roof_B");
  73.     }
  74.     std::shared_ptr<House> getHouse(){
  75.         return house;
  76.     }
  77. };
  78.  
  79. // 指挥者
  80. class Director{
  81. public:
  82.     void setBuilder(std::shared_ptr<AbstractBuilder> ibuilder){        
  83.         builder = ibuilder;
  84.     }
  85.     // 封装组装流程，返回建造结果    
  86.     std::shared_ptr<House> construct(){
  87.         builder->buildFloor();
  88.         builder->buildRoof();
  89.         builder->buildWall();
  90.         return builder->getHouse();
  91.     }
  92.  
  93. private:    
  94.     std::shared_ptr<AbstractBuilder> builder;
  95. };
  96.  
  97. #endif

main.cpp

  1. #include <iostream>
  2. #include "BuilderPattern.h"
  3.  
  4. int main(){     
  5.     // 指定具体建造者A  
  6.     std::shared_ptr<Director> d = std::make_shared<Director>();
  7.     std::shared_ptr<ConcreteBuilderA> cba = std::make_shared<ConcreteBuilderA>();
  8.     d->setBuilder(cba);
  9.     std::shared_ptr<House> h = d->construct();
  10.     h->printfHouseInfo();
  11.  
  12.     std::cout << "---------------------------\n";
  13.     // 指定具体建造者B
  14.     std::shared_ptr<ConcreteBuilderB> cbb = std::make_shared<ConcreteBuilderB>();
  15.     d->setBuilder(cbb);
  16.     h = d->construct();
  17.     h->printfHouseInfo();
  18.  
  19.     return 0;
  20. }

⑤ 原型模式

原型模式通过复制一个已有对象来获取更多相同或者相似的对象。

例1

报错如下：Segmentation fault: 11 空指针问题

PrototypePattern.h

  1. #ifndef __PROTOTYPE_PATTERN__
  2. #define __PROTOTYPE_PATTERN__
  3.  
  4. #include <iostream>
  5.  
  6. class WorkModel{
  7. public:
  8.     void setWorkModelName(std::string imodelName){
  9.         modelName = imodelName;
  10.     }
  11.     std::string getWorkModelName(){
  12.         return modelName;
  13.     }
  14. private:
  15.     std::string modelName;
  16. };
  17.  
  18. class ConcreteWork {
  19. public:
  20.     std::shared_ptr<ConcreteWork> clone(){
  21.         std::shared_ptr<ConcreteWork> cw = std::make_shared<ConcreteWork>();
  22.         cw->setIdNum(idNum);
  23.         cw->setIdName(idName);
  24.         cw->setIWorkModel(iWorkModel);
  25.         return cw;
  26.     }
  27.     std::shared_ptr<WorkModel> getIWorkModel(){
  28.         return iWorkModel;
  29.     }
  30.     void setIdNum(int iIdNum){
  31.         idNum = iIdNum;
  32.     }
  33.     void setIdName(std::string iIdName){
  34.         idName = iIdName;
  35.     }
  36.     void setIWorkModel(std::shared_ptr<WorkModel> iIWorkModel){
  37.         iWorkModel = iIWorkModel;
  38.     }
  39.     void printWorkInfo(){
  40.         std::cout << "Name: " << idName << "\n";
  41.         std::cout << "Num: "  << idNum  << "\n";
  42.         std::cout << "ModelName: " << iWorkModel->getWorkModelName() << "\n";
  43.     }
  44.  
  45. private:
  46.     int idNum;
  47.     std::string idName;
  48.     std::shared_ptr<WorkModel> iWorkModel;
  49. };
  50.  
  51. #endif

main.cpp 

  1. #include <iostream>
  2. #include "PrototypePattern.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<ConcreteWork> singleWork = std::make_shared<ConcreteWork>();
  6.     singleWork->setIdNum(1001);
  7.     singleWork->setIdName("single");
  8.     std::shared_ptr<WorkModel> singleWorkModel = singleWork->getIWorkModel();
  9.     // 错：singleWorkModel是空指针，执行setWorkModelName（）会报错！
  10.     singleWorkModel->setWorkModelName("single_model"); 
  11.     std::cout << "single完成了作业:\n";
  12.  
  13.     return 0;
  14. }

改正如下：

PrototypePattern.h

  1. #ifndef __PROTOTYPE_PATTERN__
  2. #define __PROTOTYPE_PATTERN__
  3.  
  4. #include <iostream>
  5.  
  6. class WorkModel{
  7. public:
  8.     void setWorkModelName(std::string imodelName){
  9.         modelName = imodelName;
  10.     }
  11.     std::string getWorkModelName(){
  12.         return modelName;
  13.     }
  14. private:
  15.     std::string modelName;
  16. };
  17.  
  18. class ConcreteWork {
  19. public:
  20.     std::shared_ptr<ConcreteWork> clone(){
  21.         std::shared_ptr<ConcreteWork> cw = std::make_shared<ConcreteWork>();
  22.         cw->setIdNum(idNum);
  23.         cw->setIdName(idName);
  24.         cw->setIWorkModel(iWorkModel);
  25.         return cw;
  26.     }
  27.     void setIdNum(int iIdNum){
  28.         idNum = iIdNum;
  29.     }
  30.     void setIdName(std::string iIdName){
  31.         idName = iIdName;
  32.     }
  33.     void setIWorkModel(std::shared_ptr<WorkModel> iIWorkModel){
  34.         iWorkModel = iIWorkModel;
  35.     }
  36.     void printWorkInfo(){
  37.         std::cout << "Name: " << idName << "\n";
  38.         std::cout << "Num: "  << idNum  << "\n";
  39.         std::cout << "ModelName: " << iWorkModel->getWorkModelName() << "\n";
  40.     }
  41.  
  42. private:
  43.     int idNum;
  44.     std::string idName;
  45.     std::shared_ptr<WorkModel> iWorkModel;
  46. };
  47.  
  48. #endif

main.cpp 

  1. #include <iostream>
  2. #include "PrototypePattern.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<ConcreteWork> singleWork = std::make_shared<ConcreteWork>();
  6.     singleWork->setIdNum(1001);
  7.     singleWork->setIdName("single");
  8.     std::shared_ptr<WorkModel> workModel = std::make_shared<WorkModel>();
  9.     workModel->setWorkModelName("single_model");
  10.     singleWork->setIWorkModel(workModel);
  11.     singleWork->printWorkInfo();
  12.  
  13.    std::shared_ptr<ConcreteWork> jungleWork = singleWork->clone();
  14.    std::cout << "jungle正在抄作业...\n";
  15.  
  16.    std::cout << "jungle抄完了，正在改名字和学号，否则会被老师查出来...\n";
  17.    jungleWork->setIdNum(1002);
  18.    jungleWork->setIdName("jungle");
  19.    workModel = std::make_shared<WorkModel>();
  20.    workModel->setWorkModelName("jungle_Model");
  21.    jungleWork->setIWorkModel(workModel);
  22.  
  23.    std::cout << "jungle也完成了作业:\n";
  24.    jungleWork->printWorkInfo();
  25.  
  26.     return 0;
  27. }

⑥ 单例模式

c++ 单例模式_乒乒乓乓丫的博客-CSDN博客

Singleton.h

  1. #ifndef __SINGLETON_H__
  2. #define __SINGLETON_H__
  3.  
  4. #include <iostream>
  5. #include <mutex>
  6.  
  7. std::mutex m_mutex;
  8.  
  9. // 懒汉单例模式
  10. class Singleton_Lazy{
  11. public:
  12.     static std::shared_ptr<Singleton_Lazy> getInstance(){
  13.         std::cout << "singleton lazy mode.\n";
  14.         if(instance == nullptr){
  15.             m_mutex.lock();     // 加锁
  16.             if(instance == nullptr){
  17.                 std::cout << "创建新的实例.\n";
  18.                 instance = std::make_shared<Singleton_Lazy>();
  19.             }
  20.             m_mutex.unlock();   // 解锁
  21.         }
  22.         return instance;
  23.     }
  24.     
  25. private:
  26.     static std::shared_ptr<Singleton_Lazy> instance;
  27. };
  28.  
  29. std::shared_ptr<Singleton_Lazy> Singleton_Lazy::instance = nullptr;
  30.  
  31. // 饿汉单例模式
  32. class Singleton_Hungry{
  33. public:
  34.     static std::shared_ptr<Singleton_Hungry> getInstance(){
  35.         std::cout << "singleton hungry mode.\n";
  36.         instance = std::make_shared<Singleton_Hungry>();
  37.         return instance;
  38.     }
  39. private:
  40.     static std::shared_ptr<Singleton_Hungry> instance;
  41. };
  42.  
  43. std::shared_ptr<Singleton_Hungry> Singleton_Hungry::instance = nullptr;
  44.  
  45. #endif

main.cpp

  1. #include <iostream>
  2. #include "Singleton.h"
  3. #include <pthread.h>
  4.  
  5. #define THREAD_NUM 6
  6.  
  7. void* callSingleton_Lazy(void*){
  8.     std::shared_ptr<Singleton_Lazy> sl = Singleton_Lazy::getInstance();
  9.     std::cout << "线程编号: " << pthread_self() << "\n";
  10. }
  11.  
  12. void* callSingleton_Hungry(void*){
  13.     std::shared_ptr<Singleton_Hungry> sh = Singleton_Hungry::getInstance();
  14.     std::cout << "线程编号: " << pthread_self() << "\n";
  15. }
  16.  
  17. int main(){
  18.     pthread_t threads_pool[THREAD_NUM];
  19.     int tids[THREAD_NUM];
  20.     // 线程具有属性，用pthread_attr_t表示，在对该结构进行处理之前必须进行初始化，在使用后需要对其去除初始化。
  21.     pthread_attr_t attr;
  22.     void* status;
  23.  
  24.     // 创建 pthread_attr_t
  25.     pthread_attr_init(&attr);       
  26.  
  27.     // 线程的分离状态决定一个线程以什么样的方式来终止自己。在默认情况下线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束。
  28.     // 只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。
  29.     // PTHREAD _CREATE_JOINABLE（非分离线程）
  30.     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  31.  
  32.     for(int i = 0; i < THREAD_NUM; i++){
  33.         if(i < THREAD_NUM / 2){
  34.             // 线程创建 pthread_create
  35.             tids[i] = pthread_create(&threads_pool[i], nullptr, callSingleton_Lazy, (void*)&i);
  36.         }else {
  37.             std::cout << "-----------------\n";
  38.             tids[i] = pthread_create(&threads_pool[i], nullptr, callSingleton_Hungry, (void*)&i);
  39.         }
  40.         if(tids[i]){
  41.             std::cout << "Error: unable to create thread.\n";
  42.             return 0;
  43.         }
  44.     }
  45.  
  46.     // 销毁 pthread_attr_t
  47.     pthread_attr_destroy(&attr);    
  48.     for(int i = 0; i < THREAD_NUM; i++){
  49.         // pthread_join 主线程阻塞
  50.         tids[i] = pthread_join(threads_pool[i], &status);
  51.         if(tids[i]){
  52.             std::cout << "Error: unable to join.\n";
  53.             return 0;
  54.         }
  55.     }
  56.     std::cout << "main exiting.\n";
  57.  
  58.     return 0;
  59. }

⑦ 适配器模式

AdapterPattern.h

  1. #ifndef __ADAPTERPATTERN_H__
  2. #define __ADAPTERPATTERN_H__
  3.  
  4. #include <iostream>
  5.  
  6. // 适配者类DxfParser
  7. class DxfParser{
  8. public:
  9.     void parseFile(){
  10.         std::cout << "Parse dxf file\n";
  11.     }
  12. };
  13.  
  14. // 适配者类PathPlanner
  15. class PathPlanner{
  16. public:
  17.     void calculate(){
  18.         std::cout << "calculate path\n";
  19.     }
  20. };
  21.  
  22. class Adapter{
  23. public:
  24.     void pathPlanning(){
  25. 		std::cout << "pathPlanning\n";
  26.         dxfParser->parseFile();
  27.         pathPlanner->calculate();
  28. 	}
  29. private:
  30.     std::shared_ptr<DxfParser>   dxfParser;
  31.     std::shared_ptr<PathPlanner> pathPlanner;
  32. };
  33.  
  34. #endif

main.cpp 

  1. #include <iostream>
  2. #include "AdapterPattern.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<Adapter> adapter = std::make_shared<Adapter>();
  6.     adapter->pathPlanning();
  7.  
  8.     return 0;
  9. }

⑧  桥接模式

BridgePattern.h

  1. #ifndef __BRIDGE_PATTERN_H__
  2. #define __BRIDGE_PATTERN_H__
  3.  
  4. #include <iostream>
  5.  
  6. // 抽象类Game
  7. class Game{
  8. public:
  9.     virtual void play() = 0;
  10. };
  11.  
  12. class GameA : public Game {
  13. public:
  14.     void play(){
  15.         std::cout << "Jungle玩游戏A\n";
  16.     }
  17. };
  18.  
  19. class GameB : public Game {
  20. public:
  21.     void play(){
  22.         std::cout << "Jungle玩游戏B\n";
  23.     }
  24. };
  25.  
  26. // 抽象类Phone
  27. class Phone{
  28. public:
  29.     virtual void setUpGame(std::shared_ptr<Game> igame) = 0;
  30.     virtual void play() = 0;
  31. private:
  32.     std::shared_ptr<Game> game;
  33. };
  34.  
  35. class PhoneA : public Phone{
  36. public:
  37.     void setUpGame(std::shared_ptr<Game> igame){
  38.         game = igame;
  39.     }
  40.     void play(){
  41.         game->play();
  42.     }
  43. private:
  44.     std::shared_ptr<Game> game;
  45. };
  46.  
  47. class PhoneB : public Phone{
  48. public:
  49.     void setUpGame(std::shared_ptr<Game> igame){
  50.         game = igame;
  51.     }
  52.     void play(){
  53.         game->play();
  54.     }
  55. private:
  56.     std::shared_ptr<Game> game;
  57. };
  58.  
  59. #endif

main.cpp

  1. #include <iostream>
  2. #include "BridgePattern.h"
  3.  
  4. int main(){
  5.     // Jungle买了PhoneA品牌的手机，想玩游戏A
  6.     std::shared_ptr<PhoneA> phoneA = std::make_shared<PhoneA>();
  7.     std::shared_ptr<GameA> gameA = std::make_shared<GameA>();
  8.     phoneA->setUpGame(gameA);
  9.     phoneA->play();
  10.  
  11.     std::cout << "----------------\n";
  12.     // Jungle想在这个手机上玩游戏B
  13.     std::shared_ptr<GameB> gameB = std::make_shared<GameB>();
  14.     phoneA->setUpGame(gameB);
  15.     phoneA->play();
  16.  
  17.     return 0;
  18. }

⑨  组合模式

  • 派生类中如果没有完全实现基类的所有纯虚函数，则此时的派生类也是抽象类，不能实例化对象。换言之，抽象类的派生类是允许不实现基类的所有纯虚函数的。

CompositePattern.h

  1. #ifndef __COMPOSITE_PATTERN_H__
  2. #define __COMPOSITE_PATTERN_H__
  3.  
  4. #include <iostream>
  5. #include <vector>
  6.  
  7. // 抽象构件
  8. class Component{
  9. public:
  10.     Component(){}
  11.     Component(std::string iName){name = iName;}
  12.     // 增加一个部门或办公室
  13. 	virtual void add(std::shared_ptr<Component> com) = 0;
  14.     // 撤销一个部门或办公室
  15. 	virtual void remove(std::shared_ptr<Component> com) = 0;
  16.     //
  17.     virtual std::shared_ptr<Component> getChild(int num) = 0;
  18.     // 各部门操作
  19.     virtual void operation() = 0;
  20.     std::string getName(){
  21.         return name;
  22.     }
  23.  
  24. private:
  25.     std::string name;
  26. };
  27.  
  28. // 叶子构件：办公室
  29. // 没实现operation()，所以抽象类Component的子类Office也是抽象类，不能实例化！
  30. class Office : public Component{
  31. public:
  32.     Office(){}
  33.     Office(std::string iName){name = iName;}
  34.     void add(std::shared_ptr<Component> com){
  35.         std::cout << "not support!\n";
  36.     }
  37.     void remove(std::shared_ptr<Component> com){
  38.         std::cout << "not support!\n";
  39.     }
  40.     std::shared_ptr<Component> getChild(int num){
  41.         std::cout << "not support!\n";
  42.         return nullptr;
  43.     }    
  44.  
  45. private:
  46.     std::string name;
  47. };
  48.  
  49. // 叶子构件：行政办公室
  50. // 虽然没实现add()、remove()、getChild()，但其基类Office已经实现过了这部分 ——>
  51. // 所以派生类AdminOffice虽然只实现了operation(), 但其仍然可以实例化！
  52. class AdminOffice : public Office{
  53. public:
  54.     AdminOffice(){}
  55.     AdminOffice(std::string iName){name = iName;}    
  56.  
  57.     void operation(){
  58.         std::cout << "-----Administration Office: " << name << "\n";
  59.     }
  60.  
  61. private:
  62.     std::string name;
  63. };
  64.  
  65. // 叶子构件：教务办公室
  66. // 可以实例化，原因同AdminOffice
  67. class DeanOffice : public Office{
  68. public:
  69.     DeanOffice(){}
  70.     DeanOffice(std::string iName){name = iName;}
  71.  
  72.     void operation(){
  73.         std::cout << "-----Dean Office: " << name << "\n";
  74.     }
  75.  
  76. private:
  77.     std::string name;
  78. };
  79.  
  80. // 容器构件SubComponent
  81. // 实现了Component的所有纯虚函数，所以SubComponent可以实例化！
  82. class SubComponent : public Component{
  83. public:
  84.     SubComponent(){}
  85.     SubComponent(std::string iName){
  86.         name = iName;
  87.     }
  88.     void add(std::shared_ptr<Component> com){
  89.         componentList.push_back(com);
  90.     } 
  91.     void remove(std::shared_ptr<Component> com){
  92.         for(int i = 0; i < componentList.size(); i++){
  93.             // 遍历查找
  94.             if(componentList[i]->getName() == com->getName()){
  95.                 componentList.erase(componentList.begin() + 1);
  96.                 break;
  97.             }
  98.         }
  99.     }
  100.     std::shared_ptr<Component> getChild(int num){
  101.         return componentList[num];
  102.     }
  103.     void operation(){
  104.         std::cout << name << "\n";
  105.         for(int i = 0; i < componentList.size(); i++){
  106.             componentList[i]->operation();
  107.         }
  108.     }
  109.  
  110. private:
  111.     std::string name;
  112.     // 构件列表
  113.     std::vector<std::shared_ptr<Component> > componentList;
  114. };
  115.  
  116. #endif

main.cpp

  1. #include <iostream>
  2. #include "CompositePattern.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<SubComponent> head   = std::make_shared<SubComponent>("总部");
  6.     std::shared_ptr<SubComponent> sichuanBranch = std::make_shared<SubComponent>("四川分部");    
  7.     std::shared_ptr<AdminOffice> office1 = std::make_shared<AdminOffice>("行政办公室");    
  8.     std::shared_ptr<DeanOffice>  office2 = std::make_shared<DeanOffice>("教务办公室");    
  9.  
  10.     std::shared_ptr<SubComponent> cdBranch = std::make_shared<SubComponent>("成都分部");
  11.     std::shared_ptr<SubComponent> myBranch = std::make_shared<SubComponent>("绵阳分部");    
  12.     std::shared_ptr<AdminOffice> office3 = std::make_shared<AdminOffice>("行政办公室");    
  13.     std::shared_ptr<DeanOffice>  office4 = std::make_shared<DeanOffice>("教务办公室"); 
  14.  
  15.     std::shared_ptr<AdminOffice> office5 = std::make_shared<AdminOffice>("行政办公室");    
  16.     std::shared_ptr<DeanOffice>  office6 = std::make_shared<DeanOffice>("教务办公室"); 
  17.  
  18.     std::shared_ptr<AdminOffice> office7 = std::make_shared<AdminOffice>("行政办公室");    
  19.     std::shared_ptr<DeanOffice>  office8 = std::make_shared<DeanOffice>("教务办公室"); 
  20.  
  21.     cdBranch->add(office5);
  22.     cdBranch->add(office6);
  23.  
  24.     myBranch->add(office7);
  25.     myBranch->add(office8);
  26.  
  27.     sichuanBranch->add(office3);
  28.     sichuanBranch->add(office4);
  29.     sichuanBranch->add(cdBranch);
  30.     sichuanBranch->add(myBranch);
  31.  
  32.     head->add(office1);
  33.     head->add(office2);    
  34.     head->add(sichuanBranch);    
  35.  
  36.     head->operation();
  37.  
  38.     return 0;
  39. }

⑩  装饰模式

DecoratorPattern.h

  1. #ifndef __DECORATOR_PATTERN_H__
  2. #define __DECORATOR_PATTERN_H__
  3.  
  4. #include <iostream>
  5.  
  6. // 抽象构件
  7. class Component{
  8. public:
  9. 	virtual void operation() = 0;
  10. };
  11.  
  12. // 具体构件
  13. class Phone : public Component{
  14. public:
  15. 	void operation(){
  16. 		std::cout << "手机\n";
  17. 	}
  18. };
  19.  
  20. class Decorator : public Component{
  21. public:
  22.     void operation(){
  23. 		component->operation();
  24. 	}
  25.     void setComponent(std::shared_ptr<Component> iComponent){        
  26.         component = iComponent;
  27.     }
  28.     std::shared_ptr<Component> getComponent(){
  29.         return component;
  30.     }
  31.  
  32. private:
  33.     std::shared_ptr<Component> component;
  34. };
  35.  
  36. // 具体装饰类：手机壳
  37. class DecoratorShell : public Decorator{
  38. public:
  39.     void operation(){        
  40. 		getComponent()->operation();
  41.         std::cout << "安装手机壳\n";
  42. 	}
  43. };
  44.  
  45. // 具体装饰类：手机贴纸
  46. class DecoratorSticker : public Decorator{
  47. public:
  48.     void operation(){        
  49. 		getComponent()->operation();
  50.         std::cout << "贴卡通贴纸ֽ\n";
  51. 	}
  52. };
  53.  
  54. //  具体装饰类：挂绳
  55. class DecoratorRope : public Decorator{
  56. public:
  57.     void operation(){        
  58. 		getComponent()->operation();
  59.         std::cout << "系手机挂绳\n";
  60. 	}
  61. };
  62.  
  63. #endif

main.cpp

  1. #include <iostream>
  2. #include "DecoratorPattern.h"
  3.  
  4. int main(){
  5.     std::cout << "Jungle's first phone\n";
  6.     std::shared_ptr<Phone> p = std::make_shared<Phone>();    
  7.     std::shared_ptr<DecoratorShell> ds = std::make_shared<DecoratorShell>();    
  8.     ds->setComponent(p);
  9.     ds->operation();
  10.  
  11.     std::cout << "\nJungle's second phone\n";
  12.     std::shared_ptr<DecoratorSticker> dst = std::make_shared<DecoratorSticker>();   
  13.     dst->setComponent(ds);
  14.     dst->operation();
  15.  
  16.     std::cout << "\nJungle's third phone\n";
  17.     std::shared_ptr<DecoratorRope> dr = std::make_shared<DecoratorRope>();   
  18.     dr->setComponent(dst);
  19.     dr->operation();
  20.  
  21.     return 0;
  22. }

（二）

① 外观模式

FacadePattern.h

  1. /*
  2.  * @Author: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
  3.  * @Date: 2021-08-19 11:19:57
  4.  * @LastEditors: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
  5.  * @LastEditTime: 2023-03-13 10:29:14
  6.  * @FilePath: /cpp_test/FacadePattern.h
  7.  * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE#
  8.  */
  9. #ifndef __FACADE_PATTERN_H__
  10. #define __FACADE_PATTERN_H__
  11.  
  12. #include <iostream>
  13.  
  14. class Memory{
  15. public:
  16.     void selfCheck(){
  17.         std::cout << "memory selfchecking......\n";
  18.     }
  19. };
  20.  
  21. class Cpu{
  22. public:
  23.     void run(){
  24.         std::cout << "running cpu......\n";
  25.     }
  26. };
  27.  
  28. class HardDisk{
  29. public:
  30.     void read(){
  31.         std::cout << "reading hardDisk......\n";
  32.     }
  33. };
  34.  
  35. class Os{
  36. public:
  37. 	void load(){
  38.         std::cout << "loading os.....\n";		
  39. 	}
  40. };
  41.  
  42. class Facade{
  43. public:
  44.     void powerOn(){
  45.         std::cout << "power on……\n";	
  46.         memory->selfCheck();
  47.         cpu->run();
  48.         hardDisk->read();
  49.         os->load();        
  50.         std::cout << "ready!\n";	        
  51.     }
  52.  
  53. private:
  54.     std::shared_ptr<Memory>   memory;
  55.     std::shared_ptr<Cpu>      cpu;
  56.     std::shared_ptr<HardDisk> hardDisk;
  57.     std::shared_ptr<Os>       os;
  58. };
  59.  
  60. #endif

main.cpp

  1. #include <iostream>
  2. #include "FacadePattern.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<Facade> f = std::make_shared<Facade>();
  6.     f->powerOn();
  7.  
  8.     return 0;
  9. }

② 享元模式

FlyweightPattern.h

  1. /*
  2.  * @Author: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
  3.  * @Date: 2021-08-19 11:19:57
  4.  * @LastEditors: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
  5.  * @LastEditTime: 2023-03-13 11:23:46
  6.  * @FilePath: /cpp_test/FlyweightPattern.h
  7.  * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
  8.  */
  9. #ifndef __FLYPATTERN_PATTERN_H__
  10. #define __FLYPATTERN_PATTERN_H__
  11.  
  12. #include <iostream>
  13. #include <vector>
  14. #include <mutex>
  15.  
  16. std::mutex m_mutex;
  17.  
  18. // 抽象享元类
  19. class NetDevice{
  20. public:
  21.     virtual std::string getName() = 0;
  22.     void print(int portNum){
  23.         std::cout << "NetDevice: " << getName() << ", port: " << portNum << "\n";
  24.     }
  25. };
  26.  
  27. // 具体享元类:集线器
  28. class Hub : public NetDevice{
  29. public:
  30.     std::string getName(){
  31.         return "集线器";
  32.     }
  33. };
  34.  
  35. // 具体享元类:交换机
  36. class Switch : public NetDevice{
  37. public:
  38.     std::string getName(){
  39. 		return "交换机";
  40. 	}
  41. };
  42.  
  43. // 享元工厂类
  44. class NetDeviceFactory{
  45. public:
  46.     NetDeviceFactory(){
  47.         std::shared_ptr<Hub> hub = std::make_shared<Hub>();        
  48.         std::shared_ptr<Switch> switcher = std::make_shared<Switch>();        
  49.         devicePool.push_back(hub);
  50.         devicePool.push_back(switcher);
  51.     }
  52.  
  53.     std::shared_ptr<NetDevice> getNetDevice(char c){        
  54.         if(c == 'S'){
  55.             return devicePool[1];
  56.         }else if (c == 'H')
  57.         {
  58.             return devicePool[0];
  59.         }else{
  60.             std::cout << "wrong input!\n";
  61.         }    
  62.         return nullptr;    
  63.     }
  64.  
  65.     // 单例模式：返回享元工厂类的唯一实例
  66.     static std::shared_ptr<NetDeviceFactory> getFactory(){
  67.         if(instance == nullptr){
  68.             m_mutex.lock();
  69.             if(instance == nullptr){
  70.                 instance = std::make_shared<NetDeviceFactory>();
  71.             }
  72.             m_mutex.unlock();
  73.         }
  74.         return instance;
  75.     }
  76.  
  77. private:
  78.     static std::shared_ptr<NetDeviceFactory> instance;
  79.     // 共享池
  80.     std::vector<std::shared_ptr<NetDevice> > devicePool;
  81. };
  82.  
  83. std::shared_ptr<NetDeviceFactory> NetDeviceFactory::instance = nullptr;
  84.  
  85. #endif

main.cpp

  1. #include <iostream>
  2. #include "FlyweightPattern.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<NetDeviceFactory> netDeviceFactory = NetDeviceFactory::getFactory();
  6.  
  7.     // 客户端1获取一个hub
  8.     std::shared_ptr<NetDevice> netDevice1 = netDeviceFactory->getNetDevice('H');
  9.     netDevice1->print(1);
  10.     // 客户端2获取一个hub
  11.     std::shared_ptr<NetDevice> netDevice2 = netDeviceFactory->getNetDevice('H');
  12.     netDevice2->print(2);
  13.     std::cout << "判断两个hub是否是同一个:\n";
  14.     std::cout << "netDevice1: " << netDevice1 << ", netDevice2: " << netDevice2 << "\n\n\n";
  15.  
  16.     // 客户端3获取一个switch
  17.     std::shared_ptr<NetDevice> netDevice3 = netDeviceFactory->getNetDevice('S');
  18.     netDevice3->print(1);
  19.     // 客户端4获取一个switch
  20.     std::shared_ptr<NetDevice> netDevice4 = netDeviceFactory->getNetDevice('S');
  21.     netDevice4->print(2);
  22.     std::cout << "判断两个switch是否是同一个:\n";
  23.     std::cout << "netDevice3: " << netDevice3 << ", netDevice4: " << netDevice4 << "\n";
  24.  
  25.     return 0;
  26. }

③ 代理模式

报错如下：

ProxyPattern.h

  1. #ifndef __FLYPATTERN_PATTERN_H__
  2. #define __FLYPATTERN_PATTERN_H__
  3.  
  4. #include <iostream>
  5. #include "time.h"
  6.  
  7. // 抽象主题角色
  8. class Subject{
  9. public:
  10. 	virtual void method() = 0;
  11. };
  12.  
  13. // 真实主题角色
  14. class RealSubject : public Subject{
  15. public:
  16. 	void method(){
  17.         std::cout << "调用业务方法\n";		
  18. 	}
  19. };
  20.  
  21. // Log类
  22. class Log{
  23. public:
  24. 	void getLog(){
  25. 		std::cout << "调用日志\n";
  26. 	}
  27. };
  28.  
  29. // 代理类
  30. class Proxy : public Subject{
  31. public:
  32.     void method(){
  33.         log->getLog();
  34.         realSubject->method();
  35.         std::cout << "方法method()调用成功!\n";
  36. 	}
  37.  
  38. private:
  39.     std::shared_ptr<RealSubject> realSubject;
  40.     std::shared_ptr<Log> log;
  41. };
  42.  
  43. #endif

main.cpp

  1. #include <iostream>
  2. #include "ProxyPattern.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<Proxy> p = std::make_shared<Proxy>();
  6.     p->method();
  7.  
  8.     return 0;
  9. }

修改如下：

ProxyPattern.h

  1. #ifndef __FLYPATTERN_PATTERN_H__
  2. #define __FLYPATTERN_PATTERN_H__
  3.  
  4. #include <iostream>
  5. #include "time.h"
  6.  
  7. // 抽象主题角色
  8. class Subject{
  9. public:
  10. 	virtual void method() = 0;
  11. };
  12.  
  13. // 真实主题角色
  14. class RealSubject : public Subject{
  15. public:
  16. 	void method(){
  17.         std::cout << "调用业务方法\n";		
  18. 	}
  19. };
  20.  
  21. // Log类
  22. class Log{
  23. public:
  24. 	void getLog(){
  25. 		std::cout << "调用日志\n";
  26. 	}
  27. };
  28.  
  29. // 代理类
  30. class Proxy : public Subject{
  31. public:
  32.     Proxy(){
  33.         realSubject = std::make_shared<RealSubject>();
  34.         log = std::make_shared<Log>();
  35.     }
  36.  
  37.     void method(){
  38.         log->getLog();
  39.         realSubject->method();
  40.         std::cout << "方法method()调用成功!\n";
  41. 	}
  42.  
  43. private:
  44.     std::shared_ptr<RealSubject> realSubject;
  45.     std::shared_ptr<Log> log;
  46. };
  47.  
  48. #endif

也可修改如下：

ProxyPattern.h

  1. #ifndef __FLYPATTERN_PATTERN_H__
  2. #define __FLYPATTERN_PATTERN_H__
  3.  
  4. #include <iostream>
  5. #include "time.h"
  6.  
  7. // 抽象主题角色
  8. class Subject{
  9. public:
  10. 	virtual void method() = 0;
  11. };
  12.  
  13. // 真实主题角色
  14. class RealSubject : public Subject{
  15. public:
  16. 	void method(){
  17.         std::cout << "调用业务方法\n";		
  18. 	}
  19. };
  20.  
  21. // Log类
  22. class Log{
  23. public:
  24. 	void getLog(){
  25. 		std::cout << "调用日志\n";
  26. 	}
  27. };
  28.  
  29. // 代理类
  30. class Proxy : public Subject{
  31. public:
  32.     void method(){
  33.         realSubject = std::make_shared<RealSubject>();
  34.         log = std::make_shared<Log>();
  35.         log->getLog();        
  36.         realSubject->method();
  37.         std::cout << "方法method()调用成功!\n";
  38. 	}
  39.  
  40. private:
  41.     std::shared_ptr<RealSubject> realSubject;
  42.     std::shared_ptr<Log> log;
  43. };
  44.  
  45. #endif

④  职责链模式

ChainOfResponsibility.h

  1. #ifndef __CHAIN_OF_RESPONSIBILITY_PATTERN_H__
  2. #define __CHAIN_OF_RESPONSIBILITY_PATTERN_H__
  3.  
  4. #include <iostream>
  5.  
  6. // 请求：票据
  7. class Bill{
  8. public:
  9.     Bill(){}
  10.     Bill(int iId, std::string iName, double iAccount){
  11.         id      = iId;
  12.         name    = iName;
  13.         account = iAccount;
  14.     }
  15.  
  16.     void print(){
  17.         std::cout << "id: " << id << "\n";
  18.         std::cout << "name: " << name << "\n";
  19.         std::cout << "account: " << account << "\n\n";
  20.     }
  21.     double getAccount(){
  22.         return account;
  23.     }
  24.  
  25. private:
  26.     int         id;
  27. 	std::string name;
  28. 	double      account;
  29. };
  30.  
  31. // 抽象处理者
  32. class Approver{
  33. public:
  34.     // 添加上级
  35. 	void setSuperior(std::shared_ptr<Approver> iApprover){
  36.         superior = iApprover;
  37.     }
  38.     // 处理请求
  39. 	virtual void handleRequest(std::shared_ptr<Bill> bill) = 0;
  40.  
  41.     std::shared_ptr<Approver> getSuperior(){
  42.         return superior;
  43.     }
  44.  
  45.     std::string getName(){
  46.         return name;
  47.     }
  48.  
  49.     void setName(std::string iName){
  50.         name = iName;
  51.     }
  52.  
  53. private:
  54.     std::shared_ptr<Approver> superior;
  55.     std::string name;
  56. };
  57.  
  58. // 具体处理者：组长
  59. class GroupLeader : public Approver{
  60. public:
  61.     GroupLeader(){}
  62.     GroupLeader(std::string iName){
  63.         setName(iName);
  64.     }
  65.  
  66.     void handleRequest(std::shared_ptr<Bill> bill){
  67.         if(bill->getAccount() < 10){
  68.             std::cout << "组长: " << getName() << "处理了该票据，票据信息:\n";
  69.             bill->print();
  70.         }else{
  71.             std::cout << "组长无权处理，转交上级……\n";
  72.             getSuperior()->handleRequest(bill);
  73.         }
  74.     }
  75. };
  76.  
  77. // 具体处理者：主管
  78. class Head : public Approver{
  79. public:
  80.     Head(){}
  81.     Head(std::string iName){
  82.         setName(iName);
  83.     }
  84.  
  85.     void handleRequest(std::shared_ptr<Bill> bill){
  86.         if(bill->getAccount() >= 10 && bill->getAccount() < 30){
  87.             std::cout << "主管: " << getName() << "处理了该票据，票据信息:\n";
  88.             bill->print();
  89.         }else{
  90.             std::cout << "主管无权处理，转交上级……\n";
  91.             getSuperior()->handleRequest(bill);
  92.         }
  93.     }
  94. };
  95.  
  96. // 具体处理者：经理
  97. class Manager : public Approver{
  98. public:
  99.     Manager(){}
  100.     Manager(std::string iName){
  101.         setName(iName);
  102.     }
  103.  
  104.     void handleRequest(std::shared_ptr<Bill> bill){
  105.         if(bill->getAccount() >= 30 && bill->getAccount() < 60){
  106.             std::cout << "经理: " << getName() << "处理了该票据，票据信息:\n";
  107.             bill->print();
  108.         }else{
  109.             std::cout << "经理无权处理，转交上级……\n";
  110.             getSuperior()->handleRequest(bill);
  111.         }
  112.     }
  113. };
  114.  
  115. // 具体处理者：老板
  116. class Boss : public Approver{
  117. public:
  118.     Boss(){}
  119.     Boss(std::string iName){
  120.         setName(iName);
  121.     }
  122.  
  123.     void handleRequest(std::shared_ptr<Bill> bill){
  124.         std::cout << "老板: " << getName() << "处理了该票据，票据信息:\n";
  125.         bill->print();
  126.     }
  127. };
  128.  
  129. #endif

main.cpp

  1. #include <iostream>
  2. #include "ChainOfResponsibility.h"
  3.  
  4. int main(){
  5.     std::shared_ptr<GroupLeader> groupLeader = std::make_shared<GroupLeader>("孙组长");
  6.     std::shared_ptr<Head> head = std::make_shared<Head>("兵主管");
  7.     std::shared_ptr<Manager> manager = std::make_shared<Manager>("春经理");
  8.     std::shared_ptr<Boss> boss = std::make_shared<Boss>("孙老板");
  9.  
  10.     // 添加上级
  11.     groupLeader->setSuperior(head);
  12.     head->setSuperior(manager);
  13.     manager->setSuperior(boss);
  14.  
  15.     // 创建报销单
  16.     std::shared_ptr<Bill> bill1 = std::make_shared<Bill>(1, "Jungle", 8);
  17.     std::shared_ptr<Bill> bill2 = std::make_shared<Bill>(2, "Lucy", 14.4);
  18.     std::shared_ptr<Bill> bill3 = std::make_shared<Bill>(3, "Jack", 32.9);
  19.     std::shared_ptr<Bill> bill4 = std::make_shared<Bill>(4, "Tom", 89);
  20.  
  21.     // 全部先交给组长审批
  22.     groupLeader->handleRequest(bill1);
  23.     groupLeader->handleRequest(bill2);
  24.     groupLeader->handleRequest(bill3);
  25.     groupLeader->handleRequest(bill4);
  26.  
  27.     return 0;
  28. }

⑤  命令模式

CommandPattern.h

  1. #ifndef __COMMAND_PATTERN_H__
  2. #define __COMMAND_PATTERN_H__
  3.  
  4. #include <iostream>
  5. #include <vector>
  6.  
  7. // 命令队列类
  8. #define COMMAND_QUEUE
  9.  
  10. // 抽象命令类 
  11. class Command{
  12. public:
  13. 	virtual void execute() = 0;
  14. };
  15.  
  16. // 接收者：电灯类
  17. class Lamp{
  18. public:
  19.     void on(){
  20. 		lampState = true;
  21. 		std::cout << "Lamp is on\n";
  22. 	}
  23.     void off(){
  24. 		lampState = false;
  25. 		std::cout << "Lamp is off\n";
  26. 	}
  27.     bool getLampState(){
  28.         return lampState;
  29.     }
  30.  
  31. private:
  32.     bool lampState;
  33. };
  34.  
  35. // 接收者：风扇类
  36. class Fan{
  37. public:
  38.     void on(){
  39. 		fanState = true;
  40. 		std::cout << "Fan is on\n";
  41. 	}
  42.     void off(){
  43. 		fanState = false;
  44. 		std::cout << "Fan is off\n";
  45. 	}
  46.     bool getFanState(){
  47.         return fanState;
  48.     }
  49.  
  50. private:
  51.     bool fanState;
  52. };
  53.  
  54. // 具体命令类 LampCommand
  55. class LampCommand : public Command{
  56. public:
  57.     LampCommand(){
  58.         lamp = std::make_shared<Lamp>();
  59.     }
  60.     void execute(){
  61.         if(lamp->getLampState()){
  62.             lamp->off();
  63.         }else{
  64.             lamp->on();
  65.         }
  66.     }
  67.  
  68. private:
  69.     std::shared_ptr<Lamp> lamp;
  70. };
  71.  
  72. // 具体命令类 FanCommand
  73. class FanCommand : public Command{
  74. public:
  75.     FanCommand(){
  76.         fan = std::make_shared<Fan>();
  77.     }
  78.     void execute(){
  79.         if(fan->getFanState()){
  80.             fan->off();
  81.         }else{
  82.             fan->on();
  83.         }
  84.     }
  85.  
  86. private:
  87.     std::shared_ptr<Fan> fan;
  88. };
  89.  
  90. // 调用者 Button
  91. class Button{
  92. public:    
  93.     void setCommand(std::shared_ptr<Command> iCom){
  94.         command = iCom;
  95.     }
  96.     void touch(){
  97.         std::cout << "触摸开关:\n";
  98.         command->execute();
  99.     }
  100.  
  101. private:
  102.     std::shared_ptr<Command> command;
  103. };
  104.  
  105. #ifdef COMMAND_QUEUE
  106.  
  107. // 命令队列类
  108. class CommandQueue{
  109. public:
  110.     void addCommand(std::shared_ptr<Command> com){
  111.         commandQueue.push_back(com);
  112.     }
  113.     void execute(){
  114.         for(int i = 0; i < commandQueue.size(); i++){
  115.             commandQueue[i]->execute();
  116.         }
  117.     }
  118.  
  119. private:
  120.     std::vector<std::shared_ptr<Command> > commandQueue;
  121. };
  122.  
  123. // 调用者 Button2
  124. class Button2{
  125. public:
  126.     void setCommandQueue(std::shared_ptr<CommandQueue> iCommandQueue){
  127.         commandQueue = iCommandQueue;
  128.     }
  129.     void touch(){
  130.         std::cout << "触摸开关:\n";
  131.         commandQueue->execute();
  132.     }
  133.  
  134. private:
  135.     std::shared_ptr<CommandQueue> commandQueue;
  136. };
  137.  
  138. #endif
  139.  
  140. #endif

main.cpp

  1. #include <iostream>
  2. #include "CommandPattern.h"
  3.  
  4. int main(){
  5.     // 按钮
  6.     std::shared_ptr<Button> bt = std::make_shared<Button>();
  7.     // 按钮控制电灯
  8.     std::shared_ptr<LampCommand> lc = std::make_shared<LampCommand>();
  9.     bt->setCommand(lc);
  10.     bt->touch();
  11.     bt->touch();
  12.     bt->touch();
  13.     bt->touch();
  14.     std::cout << "\n\n";
  15.  
  16.     std::shared_ptr<FanCommand> fc = std::make_shared<FanCommand>();
  17.     bt->setCommand(fc);
  18.     bt->touch();
  19.     bt->touch();
  20.     bt->touch();
  21.     bt->touch();
  22.     std::cout << "-------------------------\n";
  23.  
  24. #ifdef COMMAND_QUEUE
  25.     std::shared_ptr<Button2> bt2 = std::make_shared<Button2>();    
  26.     std::shared_ptr<CommandQueue> cq = std::make_shared<CommandQueue>();       
  27.     cq->addCommand(lc);
  28.     cq->addCommand(fc);
  29.     bt2->setCommandQueue(cq);
  30.     bt2->touch();
  31.  
  32. #endif
  33.     return 0;
  34. }

⑥ 备忘录模式

Memento.h

  1. #ifndef __MEMENTO_H__
  2. #define __MEMENTO_H__
  3.  
  4. #include <iostream>
  5.  
  6. class Memento{
  7. public:
  8.     Memento(){}
  9.     Memento(int iVersion, std::string iDate, std::string iLabel){
  10.         version = iVersion;
  11.         date    = iDate;
  12.         label   = iLabel;
  13.     }
  14.     int getVersion(){
  15.         return version;
  16.     }
  17.     std::string getDate(){
  18.         return date;
  19.     }
  20.     std::string getLabel(){
  21.         return label;
  22.     }
  23.  
  24. private:
  25.     int         version;
  26. 	std::string date;
  27. 	std::string label;
  28. };
  29.  
  30. #endif

Originator.h

  1. #ifndef __CODEVERSION_H__
  2. #define __CODEVERSION_H__
  3.  
  4. #include <iostream>
  5. #include "Memento.h"
  6.  
  7. class CodeVersion{
  8. public:
  9.     CodeVersion(){
  10. 		version = 0;
  11. 		date    = "1900-01-01";
  12. 		label   = "none";
  13. 	}
  14. 	CodeVersion(int iVersion, std::string iDate, std::string iLabel){
  15. 		version = iVersion;
  16. 		date    = iDate;
  17. 		label   = iLabel;
  18. 	}
  19.     std::shared_ptr<Memento> save(){
  20.         return std::make_shared<Memento>(version, date, label);
  21.     }
  22.     std::shared_ptr<Memento> commit(){
  23.         return std::make_shared<Memento>(version, date, label);
  24.     }
  25.     void restore(std::shared_ptr<Memento> mem){
  26.         version = mem->getVersion();
  27.         date    = mem->getDate();
  28.         label   = mem->getLabel();
  29.     }
  30.  
  31. private:
  32.     int         version;
  33. 	std::string date;
  34. 	std::string label;
  35. };
  36.  
  37. #endif

CodeManager.h 

  1. #ifndef __CODEMANAGER_H__
  2. #define __CODEMANAGER_H__
  3.  
  4. #include <iostream>
  5. #include <vector>
  6. #include "Memento.h"
  7.  
  8. class CodeManager{
  9. public:
  10.     void commit(std::shared_ptr<Memento> mem){
  11.         std::cout << "version: " << mem->getVersion() << 
  12.         ", date: " << mem->getDate() << ", label: " << mem->getLabel() << "\n";
  13.         mementoList.push_back(mem);
  14.     }
  15.     std::shared_ptr<Memento> switchToPointedVersion(int index){
  16.         mementoList.erase(mementoList.begin() + mementoList.size() - index, mementoList.end());
  17.         return mementoList[mementoList.size() - 1];
  18.     }
  19.     void codeLog(){
  20.         for (int i = 0; i < mementoList.size(); i++){
  21.             std::cout << "version: " << mementoList[i]->getVersion() << 
  22.             ", date: " << mementoList[i]->getDate() << ", label: " << mementoList[i]->getLabel() << "\n";
  23.         }
  24.     }
  25.  
  26. private:
  27.     std::vector<std::shared_ptr<Memento> > mementoList;
  28. };
  29.  
  30. #endif

main.cpp

  1. #include <iostream>
  2. #include "Originator.h"
  3. #include "CodeManager.h"
  4.  
  5. int main(){    
  6.     std::shared_ptr<CodeManager> Jungle  = std::make_shared<CodeManager>();    
  7.     std::shared_ptr<CodeVersion> codeVer = std::make_shared<CodeVersion>(1001, "2019-11-03", "Initial version");  
  8.  
  9.     std::cout << "提交初始版本:\n";
  10.     Jungle->commit(codeVer->save());  
  11.  
  12.     std::cout << "\n提交一个版本，增加了日志功能:\n";
  13.     codeVer = std::make_shared<CodeVersion>(1002, "2019-11-04", "Add log funciton"); 
  14.     Jungle->commit(codeVer->save());  
  15.  
  16.     std::cout << "\n提交一个版本，增加了Qt图片浏览器:\n";
  17.     codeVer = std::make_shared<CodeVersion>(1003, "2019-11-05", "Add Qt Image Browser"); 
  18.     Jungle->commit(codeVer->save());  
  19.  
  20.     std::cout << "\n查看提交历史\n";
  21.     Jungle->codeLog();
  22.  
  23.     std::cout << "\n回退到上一个版本\n";
  24.     codeVer->restore(Jungle->switchToPointedVersion(1));
  25.  
  26.     std::cout << "\n查看提交历史\n";
  27.     Jungle->codeLog();
  28.  
  29.     return 0;
  30. }

⑦ 策略模式

Strategy.h

  1. #ifndef __STRATEGY_H__
  2. #define __STRATEGY_H__
  3.  
  4. #include <iostream>
  5.  
  6. // 抽象策略类
  7. class Strategy{
  8. public:
  9.     virtual void sort(int arr[], int N) = 0;
  10. };
  11.  
  12. // 具体策略：冒泡排序
  13. class BubbleSort : public Strategy{
  14. public:
  15.     BubbleSort(){
  16. 		std::cout << "冒泡排序\n";
  17. 	}
  18.     void sort(int arr[], int N){
  19. 		for (int i = 0; i<N; i++)
  20. 		{
  21. 			for (int j = 0; j<N - i - 1; j++)
  22. 			{
  23. 				if (arr[j]>arr[j + 1]){
  24. 					int tmp = arr[j];
  25. 					arr[j] = arr[j + 1];
  26. 					arr[j + 1] = tmp;
  27. 				}
  28. 			}
  29. 		}
  30. 	}
  31. };
  32.  
  33. // 具体策略：选择排序
  34. class SelectionSort : public Strategy{
  35. public:
  36.     SelectionSort(){
  37. 		std::cout << "选择排序\n";
  38. 	}
  39.     void sort(int arr[], int N){
  40. 		int i, j, k;
  41. 		for (i = 0; i<N; i++)
  42. 		{
  43. 			k = i;
  44. 			for (j = i + 1; j<N; j++)
  45. 			{
  46. 				if (arr[j] < arr[k]){
  47. 					k = j;
  48. 				}
  49. 			}
  50. 			int temp = arr[i];
  51. 			arr[i] = arr[k];
  52. 			arr[k] = temp;
  53. 		}
  54. 	}
  55. };
  56.  
  57. // 具体策略：插入排序
  58. class InsertSort :public Strategy
  59. {
  60. public:
  61. 	InsertSort(){
  62. 		printf("插入排序\n");
  63. 	}
  64. 	void sort(int arr[], int N){
  65. 		int i, j;
  66. 		for (i = 1; i<N; i++)
  67. 		{
  68. 			for (j = i - 1; j >= 0; j--)
  69. 			{
  70. 				if (arr[i]>arr[j]){
  71. 					break;
  72. 				}
  73. 			}
  74. 			int temp = arr[i];
  75. 			for (int k = i - 1; k > j; k--){
  76. 				arr[k + 1] = arr[k];
  77. 			}
  78. 			arr[j + 1] = temp;
  79. 		}
  80. 	}
  81. };
  82.  
  83. #endif

Context.h

  1. #include <iostream>
  2. #include "Context.h"
  3.  
  4. int main(){    
  5.     std::shared_ptr<Context> ctx = std::make_shared<Context>();  
  6.     int arr[] = { 10, 23, -1, 0, 300, 87, 28, 77, -32, 2 };
  7.     ctx->setInput(arr, sizeof(arr) / sizeof(int));
  8.     std::cout << "input: ";
  9.     ctx->print();
  10.  
  11.     std::shared_ptr<BubbleSort> bubbleSort = std::make_shared<BubbleSort>();
  12.     ctx->setSortStrategy(bubbleSort);
  13.     ctx->sort();
  14.  
  15.     std::shared_ptr<SelectionSort> selectionSort = std::make_shared<SelectionSort>();
  16.     ctx->setSortStrategy(selectionSort);
  17.     ctx->sort();
  18.  
  19.     std::shared_ptr<InsertSort> insertSort = std::make_shared<InsertSort>();
  20.     ctx->setSortStrategy(insertSort);
  21.     ctx->sort();
  22.  
  23.     return 0;
  24. }

main.cpp

  1. #include <iostream>
  2. #include "Context.h"
  3.  
  4. int main(){    
  5.     std::shared_ptr<Context> ctx = std::make_shared<Context>();  
  6.     int arr[] = { 10, 23, -1, 0, 300, 87, 28, 77, -32, 2 };
  7.     ctx->setInput(arr, sizeof(arr) / sizeof(int));
  8.     std::cout << "input: ";
  9.     ctx->print();
  10.  
  11.     std::shared_ptr<BubbleSort> bubbleSort = std::make_shared<BubbleSort>();
  12.     ctx->setSortStrategy(bubbleSort);
  13.     ctx->sort();
  14.  
  15.     std::shared_ptr<SelectionSort> selectionSort = std::make_shared<SelectionSort>();
  16.     ctx->setSortStrategy(selectionSort);
  17.     ctx->sort();
  18.  
  19.     std::shared_ptr<InsertSort> insertSort = std::make_shared<InsertSort>();
  20.     ctx->setSortStrategy(insertSort);
  21.     ctx->sort();
  22.  
  23.     return 0;
  24. }

⑧ 模版方法模式

FingerprintModule.h

  1. #ifndef __FINGERPRINTMODULE_H__
  2. #define __FINGERPRINTMODULE_H__
  3.  
  4. #include <iostream>
  5.  
  6. // 基类
  7. class FingerprintModule{
  8. public:
  9. 	void getImage(){
  10. 		std::cout << "采指纹图像\n";
  11. 	}
  12. 	void output(){
  13. 		std::cout << "指纹图像处理完成!\n";		
  14. 	}
  15.  
  16. 	virtual bool isSafeMode() = 0;
  17. 	virtual void processImage() = 0;
  18. 	// 加解密
  19. 	virtual void encrypt() = 0;
  20. 	virtual void decrypt() = 0;
  21.  
  22. 	// 模板方法
  23. 	void algorithm(){
  24. 		// 1.采图
  25. 		getImage();
  26. 		// 2.安全模式下加密和解密
  27. 		if (isSafeMode())
  28. 		{
  29. 			// 2.1. 加密
  30. 			encrypt();
  31. 			// 2.2. 解密
  32. 			decrypt();
  33. 		}
  34. 		// 3.处理Image
  35. 		processImage();
  36. 		// 4.处理结果
  37. 		output();
  38. 	}
  39. };
  40.  
  41. // 派生类A
  42. class FingerprintModuleA : public FingerprintModule{
  43. public:
  44. 	bool isSafeMode(){
  45. 		std::cout << "安全模式\n";		
  46. 		return true;
  47. 	}
  48. 	void processImage(){
  49. 		std::cout << "使用 第一代版本算法 处理指纹图像\n";									
  50. 	}
  51. 	void encrypt(){
  52. 		std::cout << "使用RSA密钥加密\n";	
  53. 	}
  54. 	void decrypt(){
  55. 		std::cout << "使用RSA密钥解密\n";	
  56. 	}
  57. };
  58.  
  59. // 派生类B
  60. class FingerprintModuleB : public FingerprintModule{
  61. public:
  62. 	bool isSafeMode(){
  63. 		std::cout << "非安全模式\n";		
  64. 		return false;
  65. 	}
  66. 	void processImage(){
  67. 		std::cout << "使用 第二代版本算法 处理指纹图像\n";									
  68. 	}
  69. 	void encrypt(){}
  70. 	void decrypt(){}
  71. };
  72.  
  73. // 派生类C
  74. class FingerprintModuleC : public FingerprintModule{
  75. public:
  76. 	bool isSafeMode(){
  77. 		std::cout << "安全模式\n";		
  78. 		return true;
  79. 	}
  80. 	void processImage(){
  81. 		std::cout << "使用 第一代版本算法 处理指纹图像\n";									
  82. 	}
  83. 	void encrypt(){
  84. 		std::cout << "使用DH密钥加密\n";	
  85. 	}
  86. 	void decrypt(){
  87. 		std::cout << "使用DH密钥解密\n";	
  88. 	}
  89. };
  90.  
  91. #endif

main.cpp

  1. #include <iostream>
  2. #include "FingerprintModule.h"
  3.  
  4. int main(){    
  5.     std::shared_ptr<FingerprintModuleA> fa = std::make_shared<FingerprintModuleA>();
  6.     fa->algorithm();
  7.  
  8.     std::cout << "\n";
  9.     std::shared_ptr<FingerprintModuleB> fb = std::make_shared<FingerprintModuleB>();
  10.     fb->algorithm();
  11.  
  12.     std::cout << "\n";
  13.     std::shared_ptr<FingerprintModuleC> fc = std::make_shared<FingerprintModuleC>();
  14.     fc->algorithm();
  15.  
  16.     return 0;
  17. }

2.cmake相关

cmake教程_乒乒乓乓丫的博客-CSDN博客

例1  开源项目GitHub - qicosmos/rest_rpc: modern C++(C++11), simple, easy to use rpc framework

若直接运行server目录下的main.cpp会报错如下：'rest_rpc.hpp' file not found

原因是各头文件的路径是按CMakeLists.txt的include_directories() 来实现的：

所以，通过cmake的方式来组织文件关系， 上面的那个server目录下的main.cpp里的#include <rest_rpc.hpp> 就相当于 #include <../../include/rest_rpc.hpp>。

同理其他的如：

通过cmake执行如下：

3.网络编程

从零开始的C++网络编程 - 知乎

【阅读】《Linux高性能服务器编程》——第五章：Linux网络编程基础API - 知乎

【C++】Web服务器项目所用到的函数详解_c++ iovec_半路杀出来的小黑同学的博客-CSDN博客

TinyWebServer——从0到服务器开发！ - 知乎

① 基于socket网络编程的客户端和服务端举例

server.cpp

  1. #include <iostream>
  2. #include <sys/socket.h>   // socket, bind
  3. #include <sys/errno.h>    // errno
  4. #include <netinet/in.h>   // sockaddr_in
  5. #include <cstring>        // bzero   
  6. #include <signal.h>       // signal   
  7. #include <unistd.h>       // close
  8.  
  9. #define BUFFSIZE     2048
  10. #define DEFAULT_PORT 16555
  11. #define MAXLINK      2048
  12.  
  13. int sockfd, connfd;       // 定义服务端套接字和客户端套接字
  14.  
  15. void stopServerRunning(int){    
  16.     close(sockfd);    
  17.     std::cout << "Close Server\n";
  18.     exit(0);
  19. }
  20.  
  21. int main(){
  22.     sockaddr_in servaddr; // 结构体
  23.     char buff[BUFFSIZE];  // 用于收发数据
  24.     // 在Server端和Client端都有一个socket,通过将socket当作文件,可以写入也可读取
  25.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
  26.     if(sockfd == -1){
  27.         std::cout << "Create socket error: " << errno 
  28.         << ", :" << strerror(errno) << "\n";
  29.         return -1;
  30.     }
  31.     // void bzero(void* s, int n);//s为内存（字符串）指针，n为需要清零的字节数。
  32.     bzero(&servaddr, sizeof(servaddr));
  33.     // sin_family指代协议族，在socket编程中只能是AF_INET
  34.     servaddr.sin_family = AF_INET;      
  35.     // sin_addr存储IP地址，使用in_addr这个数据结构(in_addr.s_addr就是32位IP地址)，按照网络字节顺序存储IP地址
  36.     // htonl（Host to Network Long）把本机字节顺序转化为网络字节顺序，htons（Host to Network Short）
  37.     // INADDR_ANY转换过来就是0.0.0.0，泛指本机的意思，也就是表示本机的所有IP
  38.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  39.     servaddr.sin_port = htons(DEFAULT_PORT);      
  40.     // bind用来给socket绑定地址信息  
  41.     // 通常服务器在启动时会绑定一个总所周知的地址(ip地址+端口号)，客户端不用指定系统自动分配，
  42.     // 所以通常服务端在listen之前要调用bind()，而客户端不会调用，在connect()时由系统随机生成一个。
  43.     if(bind(sockfd, (sockaddr*)&servaddr, sizeof(servaddr)) == -1){
  44.         std::cout << "Bind error: " << errno 
  45.         << ", :" << strerror(errno) << "\n";
  46.         return -1;
  47.     }
  48.     if(listen(sockfd, MAXLINK) == -1){
  49.         std::cout << "Listen error: " << errno 
  50.         << ", :" << strerror(errno) << "\n";
  51.         return -1;
  52.     }
  53.     std::cout << "Listening...\n";
  54.  
  55.     while (true){
  56.         // 这句用于在输入Ctrl+C的时候关闭服务器
  57.         signal(SIGINT, stopServerRunning);     
  58.         connfd = accept(sockfd, nullptr, nullptr);   
  59.         if(connfd == -1){
  60.             std::cout << "Accept error: " << errno 
  61.             << ", :" << strerror(errno) << "\n";
  62.             return -1;
  63.         }
  64.         bzero(buff, BUFFSIZE);
  65.         recv(connfd, buff, BUFFSIZE - 1, 0);
  66.         std::cout << "Recv: " << buff << "\n";
  67.         send(connfd, buff, strlen(buff), 0);
  68.         close(connfd);
  69.     }    
  70.  
  71.     return 0;
  72. }
  73.  
  74.

client.cpp

  1. #include <iostream>
  2. #include <sys/socket.h>
  3. #include <sys/types.h>
  4. #include <netinet/in.h>        // sockaddr_in
  5. #include <arpa/inet.h>         // inet_pton
  6. #include <unistd.h>            // close
  7.  
  8. #define BUFFSIZE    2048
  9. #define SERVER_IP   "0.0.0.0"  // 指定服务端的IP，记得修改为你的服务端所在的ip
  10. #define SERVER_PORT 16555      // 指定服务端的port
  11.  
  12. int main(){
  13.     sockaddr_in servaddr;
  14.     char buff[BUFFSIZE];
  15.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  16.     if(sockfd == -1){
  17.         std::cout << "Create socket error: " << errno 
  18.         << ", :" << strerror(errno) << "\n";
  19.         return -1;
  20.     }
  21.     bzero(&servaddr, sizeof(servaddr));
  22.     servaddr.sin_family = AF_INET;   
  23.     // IP地址转换函数: 将点分十进制的ip地址转化为用于网络传输的数值格式
  24.     inet_pton(AF_INET, SERVER_IP, &servaddr.sin_addr);
  25.     servaddr.sin_port = htons(SERVER_PORT);  
  26.     if(connect(sockfd, (sockaddr*)&servaddr, sizeof(servaddr))){
  27.         std::cout << "Connect socket error: " << errno 
  28.         << ", :" << strerror(errno) << "\n";
  29.         return -1;
  30.     }
  31.     std::cout << "Please input: \n";
  32.     scanf("%s", buff);
  33.     send(sockfd, buff, strlen(buff), 0);
  34.     bzero(buff, sizeof(buff));
  35.     recv(sockfd, buff, BUFFSIZE - 1, 0);
  36.     std::cout << "Recv: " << buff << "\n";
  37.     close(sockfd);
  38.  
  39.     return 0;
  40. }

其中解决地址已占用问题：

 

通信效果如下：

② 30天自制C++服务器学习

GitHub - yuesong-feng/30dayMakeCppServer: 30天自制C++服务器，包含教程和源代码

（1）从一个最简单的socket开始 

server.cpp

  1. #include <stdio.h>
  2. #include <sys/socket.h>
  3. #include <arpa/inet.h>
  4. #include <string.h>
  5.  
  6. int main() {
  7.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  8.  
  9.     struct sockaddr_in serv_addr;
  10.     bzero(&serv_addr, sizeof(serv_addr));
  11.     serv_addr.sin_family = AF_INET;
  12.     serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  13.     serv_addr.sin_port = htons(8888);
  14.  
  15.     bind(sockfd, (sockaddr*)&serv_addr, sizeof(serv_addr));
  16.  
  17.     listen(sockfd, SOMAXCONN);
  18.     
  19.     struct sockaddr_in clnt_addr;
  20.     socklen_t clnt_addr_len = sizeof(clnt_addr);
  21.     bzero(&clnt_addr, sizeof(clnt_addr));
  22.  
  23.     int clnt_sockfd = accept(sockfd, (sockaddr*)&clnt_addr, &clnt_addr_len);
  24.  
  25.     printf("new client fd %d! IP: %s Port: %d\n", clnt_sockfd, inet_ntoa(clnt_addr.sin_addr), ntohs(clnt_addr.sin_port));
  26.     return 0;
  27. }

client.cpp

  1. #include <sys/socket.h>
  2. #include <arpa/inet.h>
  3. #include <string.h>
  4.  
  5. int main() {
  6.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  7.  
  8.     struct sockaddr_in serv_addr;
  9.     bzero(&serv_addr, sizeof(serv_addr));
  10.     serv_addr.sin_family = AF_INET;
  11.     serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  12.     serv_addr.sin_port = htons(8888);
  13.  
  14.     //bind(sockfd, (sockaddr*)&serv_addr, sizeof(serv_addr)); 客户端不进行bind操作
  15.  
  16.     connect(sockfd, (sockaddr*)&serv_addr, sizeof(serv_addr));    
  17.     
  18.     return 0;
  19. }

至此，day01的教程已经结束了，进入code/day01文件夹，使用make命令编译，将会得到server和client。输入命令./server开始运行，直到accept函数，程序阻塞、等待客户端连接。然后在一个新终端输入命令./client运行客户端，可以看到服务器接收到了客户端的连接请求，并成功连接。

new client fd 3! IP: 127.0.0.1 Port: 53505

但如果我们先运行客户端、后运行服务器，在客户端一侧无任何区别，却并没有连接服务器成功，因为我们day01的程序没有任何的错误处理。

事实上对于如socket,bind,listen,accept,connect等函数，通过返回值以及errno可以确定程序运行的状态、是否发生错误。在day02的教程中，我们会进一步完善整个服务器，处理所有可能的错误，并实现一个echo服务器（客户端发送给服务器一个字符串，服务器收到后返回相同的内容）。

（2）不要放过任何一个错误

util.h

  1. #ifndef UTIL_H
  2. #define UTIL_H
  3.  
  4. void errif(bool, const char*);
  5.  
  6. #endif

util.cpp

  1. #include "util.h"
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. void errif(bool condition, const char *errmsg){
  6.     if(condition){
  7.         perror(errmsg);
  8.         exit(EXIT_FAILURE);
  9.     }
  10. }

server.cpp

  1. #include <stdio.h>
  2. #include <sys/socket.h>
  3. #include <arpa/inet.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include "util.h"
  7.  
  8. int main() {
  9.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  10.     errif(sockfd == -1, "socket create error");
  11.  
  12.     struct sockaddr_in serv_addr;
  13.     bzero(&serv_addr, sizeof(serv_addr));
  14.     serv_addr.sin_family = AF_INET;
  15.     serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  16.     serv_addr.sin_port = htons(8888);
  17.  
  18.     errif(bind(sockfd, (sockaddr*)&serv_addr, sizeof(serv_addr)) == -1, "socket bind error");
  19.  
  20.     errif(listen(sockfd, SOMAXCONN) == -1, "socket listen error");
  21.     
  22.     struct sockaddr_in clnt_addr;
  23.     socklen_t clnt_addr_len = sizeof(clnt_addr);
  24.     bzero(&clnt_addr, sizeof(clnt_addr));
  25.  
  26.     int clnt_sockfd = accept(sockfd, (sockaddr*)&clnt_addr, &clnt_addr_len);
  27.     errif(clnt_sockfd == -1, "socket accept error");
  28.  
  29.     printf("new client fd %d! IP: %s Port: %d\n", clnt_sockfd, inet_ntoa(clnt_addr.sin_addr), ntohs(clnt_addr.sin_port));
  30.     while (true) {
  31.         char buf[1024];
  32.         bzero(&buf, sizeof(buf));
  33.         ssize_t read_bytes = read(clnt_sockfd, buf, sizeof(buf));
  34.         if(read_bytes > 0){
  35.             printf("message from client fd %d: %s\n", clnt_sockfd, buf);
  36.             write(clnt_sockfd, buf, sizeof(buf));
  37.         } else if(read_bytes == 0){
  38.             printf("client fd %d disconnected\n", clnt_sockfd);
  39.             close(clnt_sockfd);
  40.             break;
  41.         } else if(read_bytes == -1){
  42.             close(clnt_sockfd);
  43.             errif(true, "socket read error");
  44.         }
  45.     }
  46.     close(sockfd);
  47.     return 0;
  48. }

client.cpp

  1. #include <iostream>
  2. #include <sys/socket.h>
  3. #include <arpa/inet.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include "util.h"
  7.  
  8.  
  9. int main() {
  10.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  11.     errif(sockfd == -1, "socket create error");
  12.  
  13.     struct sockaddr_in serv_addr;
  14.     bzero(&serv_addr, sizeof(serv_addr));
  15.     serv_addr.sin_family = AF_INET;
  16.     serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  17.     serv_addr.sin_port = htons(8888);
  18.  
  19.     errif(connect(sockfd, (sockaddr*)&serv_addr, sizeof(serv_addr)) == -1, "socket connect error");
  20.     
  21.     while(true){
  22.         char buf[1024];
  23.         bzero(&buf, sizeof(buf));
  24.         scanf("%s", buf);
  25.         ssize_t write_bytes = write(sockfd, buf, sizeof(buf));
  26.         if(write_bytes == -1){
  27.             printf("socket already disconnected, can't write any more!\n");
  28.             break;
  29.         }
  30.         bzero(&buf, sizeof(buf));
  31.         ssize_t read_bytes = read(sockfd, buf, sizeof(buf));
  32.         if(read_bytes > 0){
  33.             printf("message from server: %s\n", buf);
  34.         }else if(read_bytes == 0){
  35.             printf("server socket disconnected!\n");
  36.             break;
  37.         }else if(read_bytes == -1){
  38.             close(sockfd);
  39.             errif(true, "socket read error");
  40.         }
  41.     }
  42.     close(sockfd);
  43.     return 0;
  44. }

至此，我们已经完整地开发了一个echo服务器，并且有最基本的错误处理！

但现在，我们的服务器只能处理一个客户端，我们可以试试两个客户端同时连接服务器，看程序将会如何运行。在day03的教程里，我们将会讲解Linux系统高并发的基石--epoll，并编程实现一个可以支持无数客户端同时连接的echo服务器！

（3）高并发还得用epoll 

server.cpp

  1. #include <stdio.h>
  2. #include <sys/socket.h>
  3. #include <arpa/inet.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <fcntl.h>
  7. #include <sys/epoll.h>
  8. #include <errno.h>
  9. #include "util.h"
  10.  
  11. #define MAX_EVENTS  1024
  12. #define READ_BUFFER 1024
  13.  
  14. // 设置非阻塞 
  15. void setnonblocking(int fd){
  16.     // 设置文件的flags: fcntl(fd,F_SETFL,flags);     
  17.     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  18. }
  19.  
  20. int main(){
  21.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  22.     errif(sockfd == -1, "socket create error");
  23.     
  24.     struct sockaddr_in serv_addr;
  25.     bzero(&serv_addr, sizeof(serv_addr));
  26.     serv_addr.sin_family = AF_INET;
  27.     serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  28.     serv_addr.sin_port = htons(8888);
  29.  
  30.     errif(bind(sockfd, (sockaddr*)&serv_addr, sizeof(serv_addr)) == -1, "socket bind error");
  31.  
  32.     errif(listen(sockfd, SOMAXCONN) == -1, "socket listen error");
  33.  
  34.     // 创建一个epoll文件描述符并返回，失败则返回-1
  35.     int epfd = epoll_create1(0);
  36.     errif(epfd == -1, "epoll create error");
  37.  
  38.     struct epoll_event events[MAX_EVENTS], ev;
  39.     bzero(&events, sizeof(events));
  40.     bzero(&ev, sizeof(ev));
  41.     ev.data.fd = sockfd;                                        // 该IO口为服务器socket fd（文件描述符）
  42.     // EPOLLIN：LT模式，EPOLLET：ET模式
  43.     ev.events  = EPOLLIN;                                       // 服务端最好不要用ET模式
  44.     setnonblocking(sockfd);
  45.     // 将服务器socket fd添加到epoll
  46.     epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);
  47.  
  48.     while (1){
  49.         // epoll_wait获取有事件发生的fd      
  50.         // 最大等待时间，设置为-1表示一直等待  
  51.         int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);    // 有nfds个fd发生事件
  52.         errif(nfds == -1, "epoll wait error");
  53.  
  54.         for(int i = 0; i < nfds; ++i){
  55.             if(events[i].data.fd == sockfd){                    // 发生事件的fd是服务器socket fd，表示有新客户端连接
  56.  
  57.                 struct sockaddr_in clnt_addr;
  58.                 bzero(&clnt_addr, sizeof(clnt_addr));
  59.                 socklen_t clnt_addr_len = sizeof(clnt_addr);
  60.  
  61.                 int clnt_sockfd = accept(sockfd, (sockaddr*)&clnt_addr, &clnt_addr_len);
  62.                 errif(clnt_sockfd == -1, "socket accept error");
  63.                 printf("new client fd %d! IP: %s Port: %d\n", clnt_sockfd, inet_ntoa(clnt_addr.sin_addr), ntohs(clnt_addr.sin_port));
  64.  
  65.                 bzero(&ev, sizeof(ev));
  66.                 ev.data.fd = clnt_sockfd;
  67.                 ev.events = EPOLLIN | EPOLLET;                   // 对于客户端连接，使用ET模式，可以让epoll更加高效，支持更多并发
  68.                 setnonblocking(clnt_sockfd);                     // ET需要搭配非阻塞式socket使用
  69.                 epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sockfd, &ev);
  70.             }else if (events[i].events & EPOLLIN){               // 发生事件的是客户端，并且是可读事件（EPOLLIN）
  71.                 
  72.                 char buf[READ_BUFFER];
  73.                 while(true){                                     //由于使用非阻塞IO，读取客户端buffer，一次读取buf大小数据，直到全部读取完毕
  74.                     bzero(&buf, sizeof(buf));
  75.                     ssize_t bytes_read = read(events[i].data.fd, buf, sizeof(buf));
  76.  
  77.                     if(bytes_read > 0){
  78.                         
  79.                         // 保存读取到的bytes_read大小的数据
  80.                         printf("message from client fd %d: %s\n", events[i].data.fd, buf);
  81.                         write(events[i].data.fd, buf, sizeof(buf));
  82.                     }else if(bytes_read == -1 && errno == EINTR){ // 客户端正常中断、继续读取
  83.  
  84.                         printf("continue reading");
  85.                         continue;
  86.                     }else if(bytes_read == -1 && ((errno == EAGAIN) || (errno == EWOULDBLOCK))){ // 非阻塞IO，这个条件表示数据全部读取完毕
  87.  
  88.                         printf("finish reading once, errno: %d\n", errno);
  89.                         break;
  90.                     }else if(bytes_read == 0){                    // EOF，客户端断开连接
  91.                     
  92.                         printf("EOF, client fd %d disconnected\n", events[i].data.fd);
  93.                         close(events[i].data.fd);                 // 关闭socket会自动将文件描述符从epoll树上移除
  94.                         break;
  95.                     }
  96.                 }
  97.             }else{ //其他事件，之后的版本实现
  98.                 printf("something else happened\n");
  99.             }            
  100.         }
  101.     }
  102.     close(sockfd);
  103.     
  104.     return 0;
  105. }

client.cpp

  1. #include <iostream>
  2. #include <sys/socket.h>
  3. #include <arpa/inet.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include "util.h"
  7.  
  8. #define BUFFER_SIZE 1024 
  9.  
  10. int main(){
  11.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  12.     errif(sockfd == -1, "socket create error");
  13.  
  14.     struct sockaddr_in serv_addr;
  15.     bzero(&serv_addr, sizeof(serv_addr));
  16.     serv_addr.sin_family = AF_INET;
  17.     serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  18.     serv_addr.sin_port = htons(8888);
  19.  
  20.     errif(connect(sockfd, (sockaddr*)&serv_addr, sizeof(serv_addr)) == -1, "socket connect error");
  21.  
  22.     while (1){
  23.         char buf[BUFFER_SIZE];  //在这个版本，buf大小必须大于或等于服务器端buf大小，不然会出错，想想为什么？
  24.         bzero(&buf, sizeof(buf));
  25.         scanf("%s", buf);
  26.         ssize_t write_bytes = write(sockfd, buf, sizeof(buf));
  27.         if(write_bytes == -1){
  28.             printf("socket already disconnected, can't write any more!\n");
  29.             break;
  30.         }
  31.  
  32.         bzero(&buf, sizeof(buf));
  33.         ssize_t read_bytes = read(sockfd, buf, sizeof(buf));
  34.         if(read_bytes > 0){
  35.             printf("message from server: %s\n", buf);
  36.         }else if(read_bytes == 0){
  37.             printf("server socket disconnected!\n");
  38.             break;
  39.         }else if(read_bytes == -1){
  40.             close(sockfd);
  41.             errif(true, "socket read error");
  42.         }
  43.     }    
  44.     close(sockfd);
  45.  
  46.     return 0;
  47. }

（4）来看看我们的第一个类

InetAddress.h

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <arpa/inet.h>
  5.  
  6. class InetAddress{
  7. public:
  8.     InetAddress();
  9.     InetAddress(std::string ip, uint16_t port);
  10.     
  11.     struct sockaddr_in getAddr(){
  12.         return addr;
  13.     }
  14.  
  15.     socklen_t getAddrLen(){
  16.         return addr_len;
  17.     }
  18.     
  19. private:
  20.     struct sockaddr_in addr;
  21.     socklen_t addr_len;    
  22. };

 InetAddress.cpp

  1. #include <iostream>
  2. #include<string.h>
  3.  
  4. #include "InetAddress.h"
  5.  
  6. InetAddress::InetAddress() : addr_len(sizeof(addr)){
  7.     bzero(&addr, sizeof(addr));
  8. }
  9.  
  10. InetAddress::InetAddress(std::string ip, uint16_t port) : addr_len(sizeof(addr)){
  11.     bzero(&addr, sizeof(addr));
  12.     addr.sin_family = AF_INET;
  13.     addr.sin_addr.s_addr = inet_addr(ip.c_str());
  14.     addr.sin_port = htons(port);
  15. }

Socket.h

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <tr1/memory>
  5.  
  6. #include "InetAddress.h"
  7.  
  8. class Socket{
  9. public:
  10.     Socket();    
  11.     Socket(int);  
  12.     ~Socket();  
  13.  
  14.     void bind(InetAddress*);
  15.     void listen();
  16.     void setnonblocking();
  17.  
  18.     int accept(InetAddress*);
  19.  
  20.     int getFd();
  21.  
  22. private:
  23.     int fd; // 文件描述符
  24. };

 Socket.cpp

  1. #include "Socket.h"
  2. #include "InetAddress.h"
  3. #include "util.h"
  4. #include <unistd.h>
  5. #include <fcntl.h>
  6. #include <sys/socket.h>
  7. #include <iostream>
  8. #include <tr1/memory>
  9.  
  10. Socket::Socket() : fd(-1){
  11.     fd = socket(AF_INET, SOCK_STREAM, 0);
  12.     errif(fd == -1, "socket create error");
  13. }
  14.  
  15. Socket::Socket(int fd_) : fd(fd_){
  16.     errif(fd == -1, "socket create error");
  17. }
  18.  
  19. Socket::~Socket(){
  20.     if(fd != -1){
  21.         close(fd);
  22.         fd = -1;
  23.     }
  24. }
  25.  
  26. void Socket::bind(InetAddress *addr){
  27.     struct sockaddr_in addrTmp = addr->getAddr();
  28.     socklen_t addrLen = addr->getAddrLen();
  29.     errif(::bind(fd, (sockaddr*)&addrTmp, addrLen) == -1, "socket bind error");
  30. }
  31.  
  32. void Socket::listen(){
  33.     errif(::listen(fd, SOMAXCONN) == -1, "socket listen error");
  34. }
  35.  
  36. void Socket::setnonblocking(){
  37.     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  38. }
  39.  
  40. int Socket::accept(InetAddress *addr){
  41.     struct sockaddr_in addrTmp = addr->getAddr();
  42.     socklen_t addrLen = addr->getAddrLen();
  43.     int clnt_sockfd = ::accept(fd, (sockaddr*)&addrTmp, &addrLen);
  44.     errif(clnt_sockfd == -1, "socket accept error");
  45.     return clnt_sockfd;
  46. }
  47.  
  48. int Socket::getFd(){
  49.     return fd;
  50. }

Epoll.h

  1. #pragma once
  2.  
  3. #include <sys/epoll.h>
  4. #include <iostream>
  5. #include <vector>
  6.  
  7. class Epoll{
  8. public:
  9.     Epoll();
  10.     ~Epoll();
  11.     void addFd(int fd, uint32_t op);
  12.     std::vector<epoll_event> poll(int timeout = -1);
  13.  
  14. private:
  15.     int epfd;
  16.     epoll_event* events;
  17. };

 Epoll.cpp

  1. #include "Epoll.h"
  2. #include "util.h"
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <iostream>
  6.  
  7. #define MAX_EVENTS 1000
  8.  
  9. Epoll::Epoll() : epfd(-1), events(nullptr){
  10.     epfd = epoll_create1(0);
  11.     errif(epfd == -1, "epoll create error");
  12.     events = new epoll_event[MAX_EVENTS];
  13.     bzero(events, sizeof(*events) * MAX_EVENTS);
  14. } 
  15.  
  16. Epoll::~Epoll(){
  17.     if(epfd != -1){
  18.         close(epfd);
  19.         epfd = -1;
  20.     }
  21.  
  22.     delete[] events; // 防止内存泄漏
  23. }
  24.  
  25. void Epoll::addFd(int fd, uint32_t op){
  26.     struct epoll_event ev;
  27.     bzero(&ev, sizeof(ev));
  28.     ev.data.fd = fd;
  29.     ev.events = op;
  30.     errif(epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) == -1, "epoll add event error");
  31. }
  32.  
  33. std::vector<epoll_event> Epoll::poll(int timeout){
  34.     std::vector<epoll_event> activeEvents;
  35.     int nfds = epoll_wait(epfd, events, MAX_EVENTS, timeout);
  36.     errif(nfds == -1, "epoll wait error");
  37.     for(int i = 0; i < nfds; ++i){
  38.         activeEvents.push_back(events[i]);
  39.     }
  40.     
  41.     return activeEvents;
  42. }

server.cpp

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <unistd.h>
  4. #include <fcntl.h>
  5. #include <errno.h>
  6. #include <vector>
  7. #include "util.h"
  8. #include "Epoll.h"
  9. #include "InetAddress.h"
  10. #include "Socket.h"
  11. #include <iostream>
  12.  
  13. #define MAX_EVENTS 1024
  14. #define READ_BUFFER 1024
  15.  
  16. void setnonblocking(int fd){
  17.     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
  18. }
  19.  
  20. void handleReadEvent(int);
  21.  
  22. int main() {
  23.     Socket *serv_sock = new Socket();
  24.     InetAddress *serv_addr = new InetAddress("127.0.0.1", 8888);
  25.     serv_sock->bind(serv_addr);
  26.     serv_sock->listen();    
  27.     Epoll *ep = new Epoll();
  28.     serv_sock->setnonblocking();
  29.     ep->addFd(serv_sock->getFd(), EPOLLIN | EPOLLET);
  30.  
  31.     while(true){
  32.         std::vector<epoll_event> events = ep->poll();
  33.         int nfds = events.size();
  34.         for(int i = 0; i < nfds; ++i){
  35.             if(events[i].data.fd == serv_sock->getFd()){  // 新客户端连接
  36.                 // new InetAddress() 位置只能在这里！
  37.                 InetAddress *clnt_addr = new InetAddress();      
  38.                 Socket *clnt_sock = new Socket(serv_sock->accept(clnt_addr));       
  39.                 printf("new client fd %d! IP: %s Port: %d\n", clnt_sock->getFd(), 
  40.                        inet_ntoa(clnt_addr->getAddr().sin_addr), ntohs(clnt_addr->getAddr().sin_port));
  41.                 clnt_sock->setnonblocking();
  42.                 ep->addFd(clnt_sock->getFd(), EPOLLIN | EPOLLET);
  43.             } else if(events[i].events & EPOLLIN){       // 可读事件
  44.                 handleReadEvent(events[i].data.fd);
  45.             } else{  // 其他事件，之后的版本实现
  46.                 printf("something else happened\n");
  47.             }
  48.         }
  49.     }
  50.     delete serv_sock;
  51.     delete serv_addr;
  52.     delete ep;
  53.  
  54.     return 0;
  55. }
  56.  
  57. void handleReadEvent(int sockfd){
  58.     char buf[READ_BUFFER];
  59.     while (1){                       // 由于使用非阻塞IO，读取客户端buffer，一次读取buf大小数据，直到全部读取完毕
  60.         bzero(&buf, sizeof(buf));
  61.         ssize_t bytes_read = read(sockfd, buf, sizeof(buf));
  62.         if(bytes_read > 0){
  63.             printf("message from client fd %d: %s\n", sockfd, buf);
  64.             write(sockfd, buf, sizeof(buf));
  65.         } else if(bytes_read == -1 && errno == EINTR){  // 客户端正常中断、继续读取
  66.             printf("continue reading");
  67.             continue;
  68.         } else if(bytes_read == -1 && ((errno == EAGAIN) || (errno == EWOULDBLOCK))){ // 非阻塞IO，这个条件表示数据全部读取完毕
  69.             printf("finish reading once, errno: %d\n", errno);
  70.             break;
  71.         } else if(bytes_read == 0){  // EOF，客户端断开连接
  72.             printf("EOF, client fd %d disconnected\n", sockfd);
  73.             close(sockfd);           // 关闭socket会自动将文件描述符从epoll树上移除
  74.             break;
  75.         }
  76.     }
  77. }

client.cpp

  1. #include <iostream>
  2. #include <sys/socket.h>
  3. #include <arpa/inet.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include "util.h"
  7.  
  8. #define BUFFER_SIZE 1024 
  9.  
  10. int main(){
  11.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  12.     errif(sockfd == -1, "socket create error");
  13.  
  14.     struct sockaddr_in serv_addr;
  15.     bzero(&serv_addr, sizeof(serv_addr));
  16.     serv_addr.sin_family = AF_INET;
  17.     serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  18.     serv_addr.sin_port = htons(8888);
  19.  
  20.     errif(connect(sockfd, (sockaddr*)&serv_addr, sizeof(serv_addr)) == -1, "socket connect error");
  21.  
  22.     while (1){
  23.         char buf[BUFFER_SIZE];  //在这个版本，buf大小必须大于或等于服务器端buf大小，不然会出错，想想为什么？
  24.         bzero(&buf, sizeof(buf));
  25.         scanf("%s", buf);
  26.         ssize_t write_bytes = write(sockfd, buf, sizeof(buf));
  27.         if(write_bytes == -1){
  28.             printf("socket already disconnected, can't write any more!\n");
  29.             break;
  30.         }
  31.  
  32.         bzero(&buf, sizeof(buf));
  33.         ssize_t read_bytes = read(sockfd, buf, sizeof(buf));
  34.         if(read_bytes > 0){
  35.             printf("message from server: %s\n", buf);
  36.         }else if(read_bytes == 0){
  37.             printf("server socket disconnected!\n");
  38.             break;
  39.         }else if(read_bytes == -1){
  40.             close(sockfd);
  41.             errif(true, "socket read error");
  42.         }
  43.     }    
  44.     close(sockfd);
  45.  
  46.     return 0;
  47. }
  1. g++ util.cpp client.cpp -o client && \
  2. g++ util.cpp server.cpp Epoll.cpp InetAddress.cpp Socket.cpp -o server

至此，我们已经完整地开发了一个echo服务器，并且引入面向对象编程的思想，初步封装了Socket、InetAddress和Epoll，大大精简了主程序，隐藏了底层语言实现细节、增加了可读性。

4. spdlog源码学习

https://www.cnblogs.com/shuqin/p/12214439.html

https://www.cnblogs.com/fortunely/p/17388565.html

简介：

  • 提供的 日志格式 非常丰富，并且允许用户自定义需要的格式。
  • 对日志文件的类型也做了充分扩展，支持控制台，普通文件，按大小滚动文件，按时间滚动文件，如果不能满足需要，可以自己扩展格式，见 spdlog/sinks/base_sink.h。
  • 支持单/多线程，异步/同步，阻塞非阻塞模式

文件结构：

代码逻辑结构： 

 

有几个比较重要的文件:

  • spdlog/spdlog.h 为日志库接口，提供日志宏的属性控制函数。
  • spdlog/logger.h 为日志管理器，为前后端连接的枢纽。
  • spdlog/async.h 为异步模式接口。
  • spdlog/sinks/base_sink.h 为日志文件格式父类，后面所有的日志文件格式都是继承该类来实现不同功能。
  • spdlog/sinks/registry.h 用于登记所有的logger，及一些默认的属性，如日志格式、日志写入等级。

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/51352
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号