cpp: Flyweight Pattern

已于 2023-05-30 21:36:32 修改
阅读量57 收藏
点赞数
分类专栏： C C++ 文章标签： 享元模式 c++ java
于 2023-05-30 21:35:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/geovindu/article/details/130957662
版权
C++ 同时被 2 个专栏收录
26 篇文章 0 订阅
订阅专栏
C
25 篇文章 0 订阅
订阅专栏
该代码实现了一个C++的享元模式示例，用于管理中国象棋和围棋棋子的绘制。通过享元工厂类FactoryChineseChess创建和缓存棋子对象，减少内存消耗。GameOfGo类用于表示围棋棋子，而ChineseChess及其子类BlackChineseChess和WhiteChineseChess则处理象棋棋子。在main函数中展示了如何使用这些类进行棋盘操作。
摘要由CSDN通过智能技术生成 
/*****************************************************************//**
 * \file   ChineseChess.h
 * \brief  享元模式 Flyweight Pattern  亦称： 缓存、Cache、Flyweight  C++ 14
 * 2023年5月30日 涂聚文 Geovin Du Visual Studio 2022 edit.
 * \author geovindu
 * \date   May 2023
 *********************************************************************/
#pragma once
#ifndef CHINESECHESS_H
#define CHINESECHESS_H
 
#include<cstring>
#include<stdbool.h>
#include<stdlib.h>
#include<iostream>
#include<malloc.h>
#include<cmath>
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <array>
#include <functional>
#include <list>
#include <string>
#include <string.h>
 
 
 
using namespace std;
 
 
 
 
namespace DuJewelryFlyweightPattern
{
 
    /// <summary>
    /// 棋子颜色
    /// </summary>
    enum EnumColor 
    {
 
        /// <summary>
        /// 黑
        /// </summary>
        Black,
        /// <summary>
        /// 白
        /// </summary>
        White  
    };
    /// <summary>
    /// 棋子位置
    /// </summary>
    struct Position
    {
 
        /// <summary>
        /// x轴
        /// </summary>
        int mX;
        /// <summary>
        /// y轴
        /// </summary>
        int mY;
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="tmpx"></param>
        /// <param name="tmpy"></param>
        Position(int tmpx, int tmpy) :mX(tmpx), mY(tmpy) {} //构造函数
    };
 
 
    /// <summary>
    /// 棋子抽象类
    /// </summary>
    class ChineseChess
    {
    public:
        /// <summary>
        /// 做父类时析构函数应该为虚函数
        /// </summary>
        virtual ~ChineseChess() {}
 
    public:
        /// <summary>
        ///
        /// </summary>
        /// <param name="tmppos"></param>
        virtual void draw(Position tmppos) = 0;
 
 
    };
 
}
 
#endif
 
/*****************************************************************//**
 * \file   BlackChineseChess.h
 * \brief  享元模式 Flyweight Pattern  亦称： 缓存、Cache、Flyweight  C++ 14
 * 2023年5月30日 涂聚文 Geovin Du Visual Studio 2022 edit.
 * \author geovindu
 * \date   May 2023
 *********************************************************************/
#pragma once
 
#ifndef BLACKCHINESECHESS_H
#define BLACKCHINESECHESS_H
 
#include<cstring>
#include<stdbool.h>
#include<stdlib.h>
#include<iostream>
#include<malloc.h>
#include<cmath>
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <array>
#include <functional>
#include <list>
#include <string>
#include <string.h>
 
#include "ChineseChess.h"
 
 
 
using namespace std;
 
 
 
 
namespace DuJewelryFlyweightPattern
{
 
    /// <summary>
    /// 黑色棋子
    /// </summary>
    class BlackChineseChess:public ChineseChess
    {
    public:
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="tmppos"></param>
        virtual void draw(Position tmppos)
        {
            cout << "在位置：(" << tmppos.mX << "," << tmppos.mY << ")处绘制了一个黑色中国象棋棋子！" << endl;
        }
 
 
 
    };
 
}
#endif
 
/*****************************************************************//**
 * \file   WhiteChineseChess.h
 * \brief  享元模式 Flyweight Pattern  亦称： 缓存、Cache、Flyweight  C++ 14
 * 2023年5月30日 涂聚文 Geovin Du Visual Studio 2022 edit.
 * \author geovindu
 * \date   May 2023
 *********************************************************************/
#pragma once
 
#ifndef WHITECHINESECHESS_H
#define WHITECHINESECHESS_H
 
#include<cstring>
#include<stdbool.h>
#include<stdlib.h>
#include<iostream>
#include<malloc.h>
#include<cmath>
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <array>
#include <functional>
#include <list>
#include <string>
#include <string.h>
 
#include "ChineseChess.h"
 
using namespace std;
 
 
 
 
namespace DuJewelryFlyweightPattern
{
 
    /// <summary>
    /// 白色棋子
    /// </summary>
    class WhiteChineseChess:public ChineseChess
    {
    public:
        /// <summary>
        ///
        /// </summary>
        /// <param name="tmppos"></param>
        virtual void draw(Position tmppos)
        {
            cout << "在位置：(" << tmppos.mX << "," << tmppos.mY << ")处绘制了一个白色中国象棋棋子！" << endl;
        }
 
 
    };
}
 
#endif
 
 
/*****************************************************************//**
 * \file   FactoryChineseChess.h
 * \brief  享元模式 Flyweight Pattern  亦称： 缓存、Cache、Flyweight  C++ 14
 * 2023年5月30日 涂聚文 Geovin Du Visual Studio 2022 edit.
 * \author geovindu
 * \date   May 2023
 *********************************************************************/
#pragma once
#ifndef FACTORYCHINESECHESS_H
#define FACTORYCHINESECHESS_H
 
#include<cstring>
#include<stdbool.h>
#include<stdlib.h>
#include<iostream>
#include<malloc.h>
#include<cmath>
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <array>
#include <functional>
#include <list>
#include <string>
#include <string.h>
#include <map>
 
 
#include "ChineseChess.h"
#include "WhiteChineseChess.h"
#include "BlackChineseChess.h"
 
using namespace std;
 
 
 
 
namespace DuJewelryFlyweightPattern
{
 
    /// <summary>
    /// 创建棋子的工厂
    /// </summary>
    class FactoryChineseChess
    {
    public:
        /// <summary>
        /// 析构函数
        /// </summary>
        ~FactoryChineseChess()
        {
            //释放内存
            for (auto iter = m_FlyWeihgtMap.begin(); iter != m_FlyWeihgtMap.end(); ++iter)
            {
                ChineseChess* tmpfw = iter->second;
                delete tmpfw;
            }
            m_FlyWeihgtMap.clear();//这句其实可有可无
        }
    public:
        /// <summary>
        /// 获取享元对象，也就是获取被共享的棋子对象
        /// </summary>
        /// <param name="tmpcolor"></param>
        /// <returns></returns>
        ChineseChess* getFlyWeight(EnumColor tmpcolor)
        {
            auto iter = m_FlyWeihgtMap.find(tmpcolor);
            if (iter == m_FlyWeihgtMap.end())
            {
                //没有该享元对象，那么就创建出来
                ChineseChess* tmpfw = nullptr;
                if (tmpcolor == Black) //黑子
                {
                    tmpfw = new BlackChineseChess();
                }
                else //白子
                {
                    tmpfw = new WhiteChineseChess();
                }
                m_FlyWeihgtMap.insert(make_pair(tmpcolor, tmpfw));//以棋子颜色枚举值为key，增加条目到map中         
                return tmpfw;
            }
            else
            {
                return iter->second;
            }
        }
    private:
        /// <summary>
        /// 在文件头增加#include <map>
        /// </summary>
        std::map<EnumColor, ChineseChess*> m_FlyWeihgtMap; //用map容器来保存所有的享元对象，一共就两个享元对象（黑色棋子一个，白色棋子一个）
 
 
    };
 
}
#endif
 
/*****************************************************************//**
 * \file   GameOfGo.h
 * \brief  享元模式 Flyweight Pattern  亦称： 缓存、Cache、Flyweight  C++ 14
 * 2023年5月30日 涂聚文 Geovin Du Visual Studio 2022 edit.
 * \author geovindu
 * \date   May 2023
 *********************************************************************/
#pragma once
#ifndef GAMEOFGO_H
#define GAMEOFGO_H
 
#include<cstring>
#include<stdbool.h>
#include<stdlib.h>
#include<iostream>
#include<malloc.h>
#include<cmath>
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <array>
#include <functional>
#include <list>
#include <string>
#include <string.h>
#include <map>
 
#include "ChineseChess.h"
 
using namespace std;
 
 
 
 
namespace DuJewelryFlyweightPattern
{
 
    /// <summary>
    /// 棋子
    /// </summary>
    class GameOfGo
    {
 
    public:
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="tmpcolor"></param>
        /// <param name="tmppos"></param>
        GameOfGo(EnumColor tmpcolor, Position tmppos) :mColor(tmpcolor), mPos(tmppos) {}
        /// <summary>
        /// 棋子的绘制
        /// </summary>
        void draw()
        {
            if (mColor == Black)
            {
                cout << "在位置：(" << mPos.mX << "," << mPos.mY << ")处绘制了一个黑色中国围棋棋子！" << endl;
                //这里可以是一系列用于具体绘制的代码......
            }
            else
            {
                cout << "在位置：(" << mPos.mX << "," << mPos.mY << ")处绘制了一个白色中国围棋棋子！" << endl;
                //这里可以是一系列用于具体绘制的代码......
            }
        }
    private:
        /// <summary>
        /// 棋子颜色
        /// </summary>
        EnumColor  mColor; 
        /// <summary>
        /// 棋子位置
        /// </summary>
        Position mPos; //
 
 
    };
 
}
 
#endif
 
/*****************************************************************//**
 * \file   GeovinDu.h
 * \brief  享元模式 Flyweight Pattern  亦称： 缓存、Cache、Flyweight  C++ 14
 * 2023年5月30日 涂聚文 Geovin Du Visual Studio 2022 edit.
 * \author geovindu
 * \date   May 2023
 *********************************************************************/
#pragma once
#ifndef GEOVINDU_H
#define GEOVINDU_H
 
#include<cstring>
#include<stdbool.h>
#include<stdlib.h>
#include<iostream>
#include<malloc.h>
#include<cmath>
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <array>
#include <functional>
#include <list>
#include <string>
#include <string.h>
 
#include "ChineseChess.h"
#include "WhiteChineseChess.h"
#include "BlackChineseChess.h"
#include "FactoryChineseChess.h"
#include "GameOfGo.h"
 
 
using namespace std;
 
 
 
 
namespace DuJewelryFlyweightPattern
{
 
    /// <summary>
    ///
    /// </summary>
    class GeovinDu
    {
 
    private:
 
    public:
 
        /// <summary>
        ///
        /// </summary>
        void displaySimple();
        /// <summary>
        ///
        /// </summary>
        void displayGoSimple();
 
 
    };
}
#endif
 
 
/*****************************************************************//**
 * \file   GeovinDu.cpp
 * \brief  享元模式 Flyweight Pattern  亦称： 缓存、Cache、Flyweight  C++ 14
 * 2023年5月30日 涂聚文 Geovin Du Visual Studio 2022 edit.
 * \author geovindu
 * \date   May 2023
 *********************************************************************/
#include "GeovinDu.h"
using namespace std;
 
 
 
 
namespace DuJewelryFlyweightPattern
{
 
    /// <summary>
    ///
    /// </summary>
    void GeovinDu::displaySimple()
    {
        DuJewelryFlyweightPattern::FactoryChineseChess* pfactory = new DuJewelryFlyweightPattern::FactoryChineseChess();
 
        DuJewelryFlyweightPattern::ChineseChess* p_piece1 = pfactory->getFlyWeight(DuJewelryFlyweightPattern::Black);
        p_piece1->draw(DuJewelryFlyweightPattern::Position(3, 3));//黑子落子到3,3位置
 
        DuJewelryFlyweightPattern::ChineseChess* p_piece2 = pfactory->getFlyWeight(DuJewelryFlyweightPattern::White);
        p_piece2->draw(DuJewelryFlyweightPattern::Position(5, 5));//白子落子到5,5位置
 
        DuJewelryFlyweightPattern::ChineseChess* p_piece3 = pfactory->getFlyWeight(DuJewelryFlyweightPattern::Black);
        p_piece3->draw(DuJewelryFlyweightPattern::Position(4, 6));//黑子落子到4,6位置
 
        DuJewelryFlyweightPattern::ChineseChess* p_piece4 = pfactory->getFlyWeight(DuJewelryFlyweightPattern::White);
        p_piece4->draw(DuJewelryFlyweightPattern::Position(5, 7));//白子落子到5,7位置
 
        //释放资源
        delete pfactory;
 
    }
 
    /// <summary>
    ///
    /// </summary>
    void GeovinDu::displayGoSimple()
    {
 
        DuJewelryFlyweightPattern::GameOfGo* p_piece1 = new DuJewelryFlyweightPattern::GameOfGo(DuJewelryFlyweightPattern::Black, DuJewelryFlyweightPattern::Position(3, 3)); //黑子落子到3,3位置
        p_piece1->draw();
 
        DuJewelryFlyweightPattern::GameOfGo* p_piece2 = new DuJewelryFlyweightPattern::GameOfGo(DuJewelryFlyweightPattern::White, DuJewelryFlyweightPattern::Position(5, 5)); //白子落子到5,5位置
        p_piece2->draw();
 
        DuJewelryFlyweightPattern::GameOfGo* p_piece3 = new DuJewelryFlyweightPattern::GameOfGo(DuJewelryFlyweightPattern::Black, DuJewelryFlyweightPattern::Position(4, 6)); //黑子落子到4,6位置
        p_piece3->draw();
 
        DuJewelryFlyweightPattern::GameOfGo* p_piece4 = new DuJewelryFlyweightPattern::GameOfGo(DuJewelryFlyweightPattern::White, DuJewelryFlyweightPattern::Position(5, 7)); //白子落子到5,7位置
        p_piece4->draw();
        //......
 
 
        std::list<DuJewelryFlyweightPattern::GameOfGo*> piecelist; //在文件头增加#include <list>
        piecelist.push_back(p_piece1);
        piecelist.push_back(p_piece2);
        piecelist.push_back(p_piece3);
        piecelist.push_back(p_piece4);
 
 
        //释放资源
        delete p_piece1;
        delete p_piece2;
        delete p_piece3;
        delete p_piece4;
 
 
    }
 
}

调用：

/*****************************************************************//**
 * \file   ConsoleDuFlyweightPattern.cpp
 * \brief  享元模式 Flyweight Pattern  亦称： 缓存、Cache、Flyweight  C++ 14
 * 2023年5月30日 涂聚文 Geovin Du Visual Studio 2022 edit.
 *
 * \author geovindu
 * \date   May 2023
 *********************************************************************/
 
// ConsoleDuFlyweightPattern.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#define _UNICODE
 
#include <iostream>
#include "GeovinDu.h"
 
#ifdef _DEBUG   //只在Debug（调试）模式下
#ifndef DEBUG_NEW
#define DEBUG_NEW new(_NORMAL_BLOCK,__FILE__,__LINE__) //重新定义new运算符
#define new DEBUG_NEW
#endif
#endif
 
using namespace std;
using namespace DuJewelryFlyweightPattern;
 
int main()
{
    std::cout << "Hello World!涂聚文 Geovin Du\n";
 
    GeovinDu geovin;
    geovin.displaySimple();
 
    cout << "************" << endl;
    geovin.displayGoSimple();
 
    system("pause");
 
    return 0;
}
 
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单
 
// 入门使用技巧:
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
#define UNICODE

输出：

Hello World!涂聚文 Geovin Du
在位置：(3,3)处绘制了一个黑色中国象棋棋子！
在位置：(5,5)处绘制了一个白色中国象棋棋子！
在位置：(4,6)处绘制了一个黑色中国象棋棋子！
在位置：(5,7)处绘制了一个白色中国象棋棋子！
************
在位置：(3,3)处绘制了一个黑色中国围棋棋子！
在位置：(5,5)处绘制了一个白色中国围棋棋子！
在位置：(4,6)处绘制了一个黑色中国围棋棋子！
在位置：(5,7)处绘制了一个白色中国围棋棋子！
请按任意键继续. . .

geovindu
关注
专栏目录
C++蝇量模式：Flyweight Pattern
lichengyang的博客
09-20 44
它是一种对性能进行优化的设计模式，通过复用蝇量对象（大量类似的对象），降低系统的内存压力（复用减少对象总数）和CPU压力（复用避免了对象的实例化，有些对象的实例化是耗时操作）。所以，需要注意的是，无可共享内部状态的对象，也是可以进行复用的（只复用不享元）。在蝇量模式中，球工厂在创建球时，即以共同大小创建球，然后交给Client，在Clinet中根据需求，对球赋予不同的颜色。指，不共享的部分，外部状态将在Client中，根据环境赋予不同的值。“大小”即为球对象的内部状态，“颜色”即为球对象的外部状态。
C++设计模式——享元模式（flyweight pattern）
净无邪博客
09-02 387
# 一、原理讲解 ## 1.1意图 运用共享技术有效地支持大量细粒度的对象。 ## 1.2应用场景 - 一个程序中使用了大量的对象； - 完全由于使用大量的对象造成很大的存储开销； - 对象的大多数状态都可变为外部状态； - 如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象； - 应用程序不依赖于对象标识。 ## 1.3结构图（UML图） ![享元模式UML结构图](https://img-blog.csdnimg.cn/20200902222642384.jpg?x-oss-
Flyweight Pattern
weixin_30813225的博客
07-20 50
1.Flyweight 模式以共享的方式高效的支持大量的细粒度对象，对象分为内部状态、外部状态。将可以被共享的状态作为内部状态存储在对象中，而外部状态在适当的时候作为参数传递给对象。 当以下所有的条件都满足时，可以考虑使用享元模式： 一个系统有大量的对象。 这些对象耗费大量的内存。 这些对象的状态中的大部分都可以外部化。 这些对象可以按照内蕴状态分成很多的组，当把外蕴对象从对象中剔除...
设计模式之十三:Flyweight（享元）—对象结构型模式
自由度
06-29 802
2014-06-15 星期日 9:35:04  Flyweight，继续GOF。 1、Intent Use sharing to support large numbers of fine-grained objects efficiently. 运用共享技术有效地支持大量细粒度的对象。 2、Also Known As 3、Motivation
C++ 享元模式 （FlyWeight Pattern）
你好，旅行者
08-30 439
//UtilTool.h //工具头文件 #pragma once #include #include #include using namespace std; //UObject.h //根基类，本想多写一些东西的，奈何时间不允许#include "UtilTool.h" class UObject { public :     UObject(string na
flyweight pattern -- 享元模式
01-09 989
flyweight pattern 又称享元模式 Use sharing to support large numbers of fine-grained objects efficiently --- GoF 运用共享技术有效地支持大量细粒度的对象 UnshareConcreteFlyweight:并不是所有的Flyweight具体实现子类都需要被共享的，如果是不能共享的，那么就只能
我所理解的设计模式（C++实现）——享元模式（Flyweight Pattern）
十八道胡同的博客专栏
05-25 9778
概述 想想我们编辑文档用的wps，文档里文字很多都是重复的，我们不可能为每一个出现的汉字都创建独立的空间，这样代价太大，最好的办法就是共享其中相同的部分，使得需要创建的对象降到最小，这个就是享元模式的核心，即运用共享技术有效地支持大量细粒度的对象。 享元对象能做到共享的关键是区分内蕴状态（Internal State）和外蕴状态（External State）。内蕴状态是存储在享元对象内部
（C++实现）——享元模式（Flyweight Pattern）
晴天的专栏
09-18 872
概述 想想我们编辑文档用的wps，文档里文字很多都是重复的，我们不可能为每一个出现的汉字都创建独立的空间，这样代价太大，最好的办法就是共享其中相同的部分，使得需要创建的对象降到最小，这个就是享元模式的核心，即运用共享技术有效地支持大量细粒度的对象。 享元对象能做到共享的关键是区分内蕴状态（Internal State）和外蕴状态（External State）。内蕴状态是存储在
Flyweight模式
KangRoger的专栏
07-14 1452
在开发时，如果创建很多对象，就会造成很大的内存开销，特别是大量轻量级（细粒度）的对象，还会造成内存碎片。Flyweight模式就是运用共享技术，有效支持大量细粒度对象的设计模式。
C++设计模式——解释器模式（interpreter pattern）
净无邪博客
11-29 1395
一、原理讲解 1.1意图 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 1.2应用场景 文法简单。对于复杂的文法，文法的类层次变得庞大而无法管理；此时语法分析程序生成器这样的工具是更好的选择。它们无法构件抽象语法树即可解释表达式，这样可以节省空间而且还可能节省时间。 效率不是关键问题。最高效的解释器通常不是通过直接解释语法分析树实现的，而是首先将它们转换成另一种形式。例如，正则表达式通常被转换成状态机。但即使在这种情况下，转换器也可用解释器模式实现，该模
C++ 享元模式
青春不老，奋斗不止！
03-20 8738
享元模式（Flyweight Pattern）运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。
C++ Qt 项目设计：数据库管理系统设计与实战
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-25 5276
跨平台C++ Qt数据库管理系统设计与实战：从理论到实践的全面解析
C++ Qt 项目设计：构建高效的代码管理器
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-26 2939
C++ Qt项目实战：构建高效的代码管理器
设计模式-享元模式
ZSS1753936255的博客
10-03 938
主要目的就是对象的共享技术，理解为：共享池。也就是我们系统的池化思想，线程池，reids连接池，数据库连接池等等）。当系统的中同类型的对象比较的时候。统一管理，主要是减少内存的开销，让系统轻量级运行，所以叫做FlyWeight模式。从上述的代码中可以看到的是 Tool t1 和 Too1 t7是同一个对象。这样的话，保持了对应的对象可以重复利用，也就是共享利用。无需实例其他额外的对象。享元模式（FlyWeight）:提供支持大量细粒度对象共享的有效方法（享元模式又称为连接池模式）
【C语言系统编程】【第三部分：网络编程】3.2 数据传输和协议
10-03 1522
在进行网络编程时，有时需要设计并实现自定义协议，以满足特定应用的需求。自定义协议设计需要考虑到数据的传输、安全、效率等多方面因素。清晰性：协议应具有清晰的语法和语义，使开发者能快速理解和实现。扩展性：协议应允许未来的功能扩展，而不破坏现有功能。安全性：数据传输过程中应考虑加密和校验，以保证数据不被篡改。高效性：应尽可能减少网络带宽占用，提升数据传输效率。容错性：协议应能处理各种网络异常情况，如数据丢失、重复和延迟。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1718
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
将脚本编译为pyd文件
cdinten的专栏
10-01 448
Python虽然作为一种解释性语言，通常是使用解释器处理脚本的方式完成工作，但是也具有和很多其他诸如C、C#语言等类似的方式，可以将.py文件编译为*.pyd文件，即Python动态链接库文件。关于动态链接库的优缺点这里就不展开细说了，具体介绍如何编译及使用。要将Python文件编译成.pyd文件，可以使用Cython，以下是基本的操作步骤。
windows C++-创建数据流代理(三)
最新发布
苏洛的博客
10-08 286
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
优化存储： Flyweight模式在图书管理系统中的应用
```cpp class Book { public: string getPublisher() { return m_publisher->getPublish(); } string getWriter() { return m_writer->getWriter(); } int getBookID() { return m_bookID; } int getPrice() { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值