处理粘包问题中服务端接受逻辑修改的解析

最新推荐文章于 2025-12-26 16:39:46 发布
原创 最新推荐文章于 2025-12-26 16:39:46 发布 · 717 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #tcp/ip #服务器 #网络

处理粘包问题中服务端接受逻辑修改的解析

void Session::handle_read(const boost::system::error_code& error, size_t bytes_transferred, std::shared_ptr<Session> shared_self)
{
    if (!error) {
        //已经移动的字符数
        int copy_len = 0;
        while (bytes_transferred > 0) {
            if (!_b_head_parse) {
                //收到的数据不足头部大小
                if (bytes_transferred + _recv_head_node->_cur_len < HEAD_LENGTH) {
                    memcpy(_recv_head_node->_data + _recv_head_node->_cur_len, _data + copy_len, bytes_transferred);
                    _recv_head_node->_cur_len += bytes_transferred;
                    ::memset(_data, 0, MAX_LENGTH);
                    _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),
                        std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2, shared_self));
                    return;
                }
                //收到的数据比头部多
                //头部剩余未复制的长度
                int head_remain = HEAD_LENGTH - _recv_head_node->_cur_len;
                memcpy(_recv_head_node->_data + _recv_head_node->_cur_len, _data + copy_len, head_remain);
                //更新已处理的data长度和剩余未处理的长度
                copy_len += head_remain;
                bytes_transferred -= head_remain;
                //获取头部数据
                short data_len = 0;
                memcpy(&data_len, _recv_head_node->_data, HEAD_LENGTH);
                cout << "data_len is " << data_len << endl;
                //头部长度非法
                if (data_len > MAX_LENGTH) {
                    std::cout << "invalid data length is " << data_len << endl;
                    _server->clearSession(_uuid);
                    return;
                }
                _recv_msg_node = make_shared<MsgNode>(data_len);
                //消息的长度小于头部规定的长度，说明数据未收全，则先将部分消息放到接收节点里
                if (bytes_transferred < data_len) {
                    memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred);
                    _recv_msg_node->_cur_len += bytes_transferred;
                    ::memset(_data, 0, MAX_LENGTH);
                    _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),
                        std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2, shared_self));
                    //头部处理完成
                    _b_head_parse = true;
                    return;
                }
                memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, data_len);
                _recv_msg_node->_cur_len += data_len;
                copy_len += data_len;
                bytes_transferred -= data_len;
                _recv_msg_node->_data[_recv_msg_node->_total_len] = '\0';
                cout << "receive data is " << _recv_msg_node->_data << endl;
                //此处可以调用Send发送测试
                Send(_recv_msg_node->_data, _recv_msg_node->_total_len);
                //继续轮询剩余未处理数据
                _b_head_parse = false;
                _recv_head_node->Clear();
                if (bytes_transferred <= 0) {
                    ::memset(_data, 0, MAX_LENGTH);
                    _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),
                        std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2, shared_self));
                    return;
                }
                continue;
            }
            //已经处理完头部，处理上次未接受完的消息数据
            //接收的数据仍不足剩余未处理的
            int remain_msg = _recv_msg_node->_total_len - _recv_msg_node->_cur_len;
            if (bytes_transferred < remain_msg) {
                memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred);
                _recv_msg_node->_cur_len += bytes_transferred;
                ::memset(_data, 0, MAX_LENGTH);
                _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),
                    std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self));
                return;
            }
            memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, remain_msg);
            _recv_msg_node->_cur_len += remain_msg;
            bytes_transferred -= remain_msg;
            copy_len += remain_msg;
            _recv_msg_node->_data[_recv_msg_node->_total_len] = '\0';
            cout << "receive data is " << _recv_msg_node->_data << endl;
            //此处可以调用Send发送测试
            Send(_recv_msg_node->_data, _recv_msg_node->_total_len);
            //继续轮询剩余未处理数据
            _b_head_parse = false;
            _recv_head_node->Clear();
            if (bytes_transferred <= 0) {
                ::memset(_data, 0, MAX_LENGTH);
                _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),
                    std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2, shared_self));
                return;
            }
            continue;
        }
    }
    else {
        std::cout << "handle read failed, error is " << error.what() << endl;
        Close();
        _server->clearSession(_uuid);
    }
}
  • 消息节点的数据结构MsgNode
class MsgNode
{
	friend class Session;
public:
	MsgNode(char* msg, short max_len) :_total_len(max_len + HEAD_LENGTH), _cur_len(0) {
		_data = new char[_total_len + 1]();
		memcpy(_data, &max_len, HEAD_LENGTH);
		memcpy(_data + HEAD_LENGTH, msg, max_len);
		_data[_total_len] = '\0';
	}
	MsgNode(short max_len) :_total_len(max_len), _cur_len(0) {
		_data = new char[_total_len + 1]();
	}
	~MsgNode() {
		delete[] _data;
	}
	void Clear() {
		::memset(_data, 0, _total_len);
		_cur_len = 0;
	}
private:
	short _cur_len;
	short _total_len;
	char* _data;
};

一、先明确核心成员与依赖

:成员变量 / 类型:作用说明
_socketBoost.Asio 的 tcp::socket 对象，用于异步读写数据
_data[MAX_LENGTH]单次异步读的临时缓冲区，存储从 socket 读取的原始字节流
_b_head_parse标记位：false 表示未解析完头部，true 表示已解析头部、正在接收消息体
_recv_head_node头部节点（智能指针），存储待解析的头部数据，包含：
_data：头部缓冲区
_cur_len：已接收的头部字节数
_total_len：固定为 HEAD_LENGTH
_recv_msg_node消息体节点（智能指针），存储待接收的消息体数据，包含：
_data：消息体缓冲区
_cur_len：已接收的消息体字节数
_total_len：头部指定的消息体长度
_server服务器类指针，用于管理会话（如 ClearSession 清理会话）
_uuid会话唯一标识，用于服务器定位并清理当前会话
MsgNode自定义的消息节点类，构造函数接收消息体长度，初始化缓冲区
HEAD_LENGTH常量，头部长度（示例中是 short 类型，通常为 2）
MAX_LENGTH常量，消息体的最大长度（防止恶意数据导致内存溢出）

二、函数参数与核心目的

void CSession::HandleRead(
    const boost::system::error_code& error,  // 异步读操作的错误码（成功时为空）
    size_t bytes_transferred,                // 异步读实际读取的字节数
    std::shared_ptr<CSession> shared_self    // 会话的智能指针（防止析构，延长生命周期）
)
  • 核心目的：作为 async_read_some 的回调函数，处理读取到的字节流，按 “头部 + 消息体” 协议解析数据，解决 TCP 粘包 / 拆包问题。
  • shared_self 的作用：异步操作是非阻塞的，若会话对象被提前析构（如服务器清理时），回调函数会访问野指针。传入shared_ptr可延长对象生命周期，直到回调执行完成。

三、代码执行流程（逐段拆解）

代码整体分为错误处理和正常数据解析两大分支，正常解析又分为头部解析阶段和消息体解析阶段。

1. 错误处理分支（异步读失败）
else {
    std::cout << "handle read failed, error is " << error.what() << endl;
    Close();  // 关闭 socket 连接
    _server->ClearSession(_uuid);  // 通知服务器清理当前会话
}
  • 当异步读操作出错（如客户端断开连接、网络异常），关闭套接字并让服务器清理会话资源。
2. 正常数据解析分支（无错误）

核心逻辑是循环处理读取到的字节流（因为单次 async_read_some 可能读取到：多个完整消息、一个不完整消息、部分头部 + 部分消息体等情况），直到bytes_transferred（剩余未处理字节数）为 0。

阶段 1：头部解析阶段（_b_head_parse = false）

此时还未解析出完整的头部，需要先接收足够的头部数据。

// 情况1：已接收的头部数据 + 本次读取的字节数 < 头部长度（头部未收全）
if (bytes_transferred + _recv_head_node->_cur_len < HEAD_LENGTH) {
    // 将本次读取的所有字节追加到头部缓冲区
    memcpy(_recv_head_node->_data + _recv_head_node->_cur_len, _data+ copy_len, bytes_transferred);
    _recv_head_node->_cur_len += bytes_transferred;
    // 清空临时缓冲区，再次发起异步读，等待剩余头部数据
    ::memset(_data, 0, MAX_LENGTH);
    _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), 
        std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self));
    return;
}
  • 若头部数据未收全，将本次读取的字节全部存入头部缓冲区，然后再次发起异步读，等待剩余头部数据。
// 情况2：已接收的头部数据 + 本次读取的字节数 >= 头部长度（头部可解析）
// 计算头部剩余未复制的字节数
int head_remain = HEAD_LENGTH - _recv_head_node->_cur_len;
// 复制剩余头部数据到头部缓冲区，补全头部
memcpy(_recv_head_node->_data + _recv_head_node->_cur_len, _data+copy_len, head_remain);
// 更新已处理的字节数（copy_len）和剩余未处理的字节数（bytes_transferred）
copy_len += head_remain;
bytes_transferred -= head_remain;

// 从头部缓冲区解析出消息体长度（short 类型）
short data_len = 0;
memcpy(&data_len, _recv_head_node->_data, HEAD_LENGTH);
cout << "data_len is " << data_len << endl;

// 校验消息体长度：若超过最大值，视为非法数据，清理会话
if (data_len > MAX_LENGTH) {
    std::cout << "invalid data length is " << data_len << endl;
    _server->ClearSession(_uuid);
    return;
}

// 创建消息体节点，缓冲区大小为解析出的消息体长度
_recv_msg_node = make_shared<MsgNode>(data_len);
  • 补全头部数据后，解析出消息体长度，并校验合法性（防止缓冲区溢出）。
// 子情况1：本次剩余字节数 < 消息体长度（消息体未收全）
if (bytes_transferred < data_len) {
    // 将本次剩余字节存入消息体缓冲区
    memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred);
    _recv_msg_node->_cur_len += bytes_transferred;
    // 清空临时缓冲区，再次发起异步读，等待剩余消息体数据
    ::memset(_data, 0, MAX_LENGTH);
    _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), 
        std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self));
    // 标记头部已解析完成，进入消息体解析阶段
    _b_head_parse = true;
    return;
}

// 子情况2：本次剩余字节数 >= 消息体长度（消息体可收全）
// 复制完整的消息体数据到消息体缓冲区
memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, data_len);
_recv_msg_node->_cur_len += data_len;
// 更新已处理和剩余字节数
copy_len += data_len;
bytes_transferred -= data_len;
// 给消息体末尾加结束符（方便打印，业务层可根据需求调整）
_recv_msg_node->_data[_recv_msg_node->_total_len] = '\0';
cout << "receive data is " << _recv_msg_node->_data << endl;

// 业务处理：发送响应（示例中是回显数据）
Send(_recv_msg_node->_data, _recv_msg_node->_total_len);

// 重置状态，准备处理下一个消息的头部
_b_head_parse = false;
_recv_head_node->Clear();  // 清空头部缓冲区，重置_cur_len为0

// 若剩余字节数为0，清空临时缓冲区，再次发起异步读
if (bytes_transferred <= 0) {
    ::memset(_data, 0, MAX_LENGTH);
    _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), 
        std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self));
    return;
}

// 若还有剩余字节数，继续循环处理（可能是下一个消息的头部/消息体）
continue;
  • 若消息体未收全，存入部分数据后再次发起异步读；若收全，则处理业务并重置状态，继续处理剩余字节。
阶段 2：消息体解析阶段（_b_head_parse = true）

此时头部已解析完成，正在接收消息体的剩余数据。

// 计算消息体剩余未接收的字节数
int remain_msg = _recv_msg_node->_total_len - _recv_msg_node->_cur_len;

// 情况1：本次读取的字节数 < 剩余消息体长度（消息体仍未收全）
if (bytes_transferred < remain_msg) {
    // 追加本次字节到消息体缓冲区
    memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred);
    _recv_msg_node->_cur_len += bytes_transferred;
    // 清空缓冲区，再次发起异步读
    ::memset(_data, 0, MAX_LENGTH);
    _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), 
        std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self));
    return;
}

// 情况2：本次读取的字节数 >= 剩余消息体长度（消息体收全）
// 复制剩余消息体数据，补全消息体
memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, remain_msg);
_recv_msg_node->_cur_len += remain_msg;
// 更新已处理和剩余字节数
bytes_transferred -= remain_msg;
copy_len += remain_msg;
// 加结束符并打印
_recv_msg_node->_data[_recv_msg_node->_total_len] = '\0';
cout << "receive data is " << _recv_msg_node->_data << endl;

// 业务处理：发送响应
Send(_recv_msg_node->_data, _recv_msg_node->_total_len);

// 重置状态，准备处理下一个消息的头部
_b_head_parse = false;
_recv_head_node->Clear();

// 若剩余字节数为0，清空缓冲区，再次发起异步读
if (bytes_transferred <= 0) {
    ::memset(_data, 0, MAX_LENGTH);
    _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH),
        std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self));
    return;
}

// 若还有剩余字节数，继续循环处理
continue;
  • 逻辑与头部解析阶段的消息体处理类似，核心是补全消息体、处理业务、重置状态。

四、关键设计

  1. 解决 TCP 粘包 / 拆包：通过 “头部定长 + 消息体变长” 的协议格式，明确消息边界，处理了以下场景：
    • 单次读取到不完整的头部 / 消息体（拆包）。
    • 单次读取到多个完整消息（粘包）。
    • 单次读取到 “部分头部 + 完整消息体 + 下一个消息的头部”（混合场景）。
  2. 生命周期管理：通过shared_self（std::shared_ptr<CSession>）绑定到回调函数，防止异步操作过程中会话对象被析构，避免野指针访问。
  3. 循环处理剩余数据：使用while循环处理单次读取的字节流，确保所有数据都被解析，不遗漏粘包的消息。
CodeDingHai
关注
netty粘包问题分析
私聊前往站内信：https://i.youkuaiyun.com/#/msg/chat/weixin_44976692
03-27 1万+
粘包问题是指发送端在将多个数据包连续发送到接收端时，接收端在接收数据时可能会将多个数据包粘合在一起，导致数据解析错误或丢失的情况。在处理粘包问题时需要注意的事项。总结解决粘包问题的方法及其优缺点，以及在实践中的应用。通过本文的学习，读者可以更深入地了解Netty中的粘包问题及其解决方案，从而更好地应对实际开发中的网络通信挑战。
C++ asio网络编程(8)处理粘包问题
筏的博客
05-18 4493
今天介绍一下如何处理粘包，粘包问题是服务器收发数据常遇到的一个现象，下面我们介绍一下粘包问题是什么，当客户端发送多个数据包给服务器时，服务器底层的tcp接收缓冲区收到的数据为粘连在一起的
基于.NET 6的C#程序中处理TCP粘包问题
极客神殿
06-30 1040
TCP 粘包问题会导致一系列问题，特别是在网络通信中需要确保消息的完整性和顺序时。
使用 Netty 自定义解码器处理粘包和拆包问题详解
微笑听雨
06-20 5357
在网络编程中，粘包和拆包问题是常见的挑战。粘包是指多个数据包在传输过程中粘在一起，而拆包是指一个数据包在传输过程中被拆分成多个部分。Netty 是一个高性能、事件驱动的网络应用框架，提供了强大的工具来解决这些问题。
C#实现TCP粘包问题的解决方案：长度头部处理
weixin_42515340的博客
06-02 814
在使用TCP协议进行数据传输时，应用程序可能会遇到所谓的"粘包"问题。粘包并不是一个正式的网络术语，它是指在连续发送数据时，由于TCP协议的流式特性，接收方无法区分数据边界，导致接收到的数据包不是发送时的原始数据包，而是多个数据包粘合在一起的情况。这种现象可以导致数据解析上的困难，尤其是当应用层协议需要精确解析每个独立消息的时候。Socket编程是网络通信编程的基础，它允许应用程序之间通过网络进行通信。在C#中，Socket类是位于System.Net命名空间下的一个类，提供了用于网络通信的丰富功能。
网络编程（7）——粘包问题
m0_63086198的博客
09-26 2039
的方式，这个过程俗称切包处理，常用的协议被称为。
Netty处理粘包与拆包
相约黄昏后
08-19 797
Netty提供了5种主要解决方案，用于处理在网络通信中产生的粘包（多个消息合并）和拆包（单个消息拆分）问题。
Dubbo源码解析处理TCP粘包拆包
luzhensmart的专栏
08-26 1043
什么是粘包拆包 此章节出自《Netty权威指南第二版》 TCP是个“流”协议，所谓流，就是没有界限的一串数据。大家可以想想河里的流水，是连成一片的，其间并没有分界线。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是所谓的TCP粘包和拆包问题。 TCP 粘包/拆包 问题解析 假设客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次读取到
131. 粘包与拆包问题
weixin_43484713的博客
05-31 1076
粘包（多个数据包被合并接收）和拆包（单个数据包被拆分接收）是网络通信中的常见问题，主要由TCP协议流式传输特性、Nagle算法、缓冲区机制等导致。解决方案包括：固定长度法（填充空字符）、分隔符法（如换行符标记边界）和推荐的长度前缀法（数据头声明包长度）。实际应用中需注意协议设计、字节序问题，并利用框架提供的解码器。粘包与拆包是TCP协议特性而非缺陷，需在应用层正确处理消息边界，高并发场景下还需考虑缓冲区管理和校验机制。典型场景包括大数据传输、高频小包发送及协议设计不当等情况。
精选资源
SuperSocket.ClientEngine.Core socket 客户端处理粘包半包
09-16
SuperSocket内建了一些预定义的ReceiveFilter，如FixedHeaderReceiveFilter（固定长度头的解析器）和LineReceiveFilter（按行分割的解析器），可以根据实际需求选择合适的过滤器来处理粘包和半包问题。 3. **实现...
TCP服务端代码解析：解决粘包拆包问题
本代码包将帮助开发者理解和处理TCP通信中粘包和拆包的问题。文档描述中提到，心跳检测与长连接操作已在前一篇文中介绍，本文将专注于解决TCP协议中的粘包和拆包问题。更详细的处理方法和相关技术知识可参见提供的...
Mina协议中解包与粘包问题处理详解
例如，当客户端连续发送两条JSON格式的消息{"cmd":"login"}和{"cmd":"heartbeat"}时，服务端可能接收到的是合并后的字符串{"cmd":"login"}{"cmd":"heartbeat"}，这就构成了典型的“粘包”问题；反之，如果某条较长的...
c++之基础A（二维数组）第四课
2302_76761070的博客
12-21 419
本文介绍了二维数组在C++游戏开发中的基本应用，特别是迷宫类游戏的实现。通过示例代码演示了二维数组的输入输出操作，以及如何计算每行和每列的和。输入输出采用双重循环结构，行列求和则分别通过固定行或列索引来实现。这些基础操作为游戏开发中处理地图数据等场景提供了实用方法，适合编程新手学习二维数组的基本使用技巧。
【C++】智能指针的使用及其原理
weixin_58252863的博客
12-21 767
本文系统介绍了C++智能指针的使用与实现原理。首先通过内存泄漏案例展示了智能指针的必要性，分析了RAII设计思想在资源管理中的应用。详细讲解了标准库中的智能指针：auto_ptr（已废弃）、unique_ptr（独占所有权）、shared_ptr（共享所有权）和weak_ptr（解决循环引用）。文章重点剖析了shared_ptr的引用计数机制及其线程安全问题，并演示了如何通过weak_ptr解决循环引用导致的内存泄漏。最后介绍了智能指针的历史渊源（与Boost库的关系）以及内存泄漏的检测与防范方法。通过自定
06_C 语言数据结构与算法：哈希表（散列表）—— O(1)查找的终极方案
C语言无原生OOP特性，却能借结构体+函数指针实现封装、继承、多态，落地工厂等设计模式。博客中以标准C语法实操教学，融入跨平台兼容设计，助开发者掌握C语言OOP核心与工程实践技巧。
12-22 1423
/ 哈希表节点（键值对，链表结构）char *key;// 键（字符串类型，可替换为int、long等）int value;// 值（整数类型，可替换为结构体等）// 下一个节点} HashNode;// 哈希表结构（数组+链表）int size;// 哈希表的大小（数组长度）// 哈希桶（数组，元素为指向链表头节点的指针）哈希表是实现O(1)查找的核心数据结构，其核心是哈希函数的均匀性和冲突解决机制。在C语言中，数组+链表的链表法。
MS-F155_C（CAN 转光纤点对点模块）特点与功能介绍
最新发布
2401_89785827的博客
12-26 559
MS-F155_C 是工业级 CAN 总线转光纤传输模块，核心功能是实现 CAN 总线电信号与光纤光信号的双向透明转换，解决 CAN 总线远距离传输衰减、电磁干扰等问题。设备采用点对点通信模式，无需复杂配置，即插即用，支持 CAN1.0/CAN2.0 协议，符合 ISO/DIS 11898 规范，可将 CAN 总线通信距离延长至多模 2000 米、单模 20~40 公里，适配工业现场 CAN 设备远距离组网、数据采集与控制场景，尤其适用于恶劣工矿环境。
csp信奥赛C++标准模板库STL案例应用9
王老师青少年编程
12-25 609
csp信奥赛C++标准模板库STL案例应用9
c++ 语言教程——17面向对象设计模式（六）
mwl0223的博客
12-25 326
本文介绍了三种行为型设计模式：访问者模式、中介者模式和解释器模式。访问者模式通过分离数据结构与操作，支持在不修改元素类的情况下添加新操作，适用于操作频繁变化的场景，但会破坏封装性。中介者模式通过引入中介对象来协调多个对象间的交互，降低耦合度，适用于需要集中管理复杂交互的系统。文章通过C++代码示例分别展示了访问者模式在商品计价场景的应用，以及中介者模式在聊天室系统中的实现，分析了各自的优缺点和适用场景。
Design Patterns In Modern C++ 中文版翻译 第八章 组合
weixin_42603425的博客
12-26 462
复合设计模式允许我们为单个对象和对象集合提供相同的接口。这可以通过显式使用接口成员来完成，也可以通过duck typing（在程序设计中是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由"当前方法和属性的集合"决定）来完成。例如基于范围的for循环并不需要您继承任何东西，而是通过实现begin()和end()。正是这些begin()/end()成员允许标量类型伪装成“集合”。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值