超越原始的结构体——序列化c++设计消息协议(C++asio网络库相关）

最新推荐文章于 2024-01-22 19:28:12 发布
最新推荐文章于 2024-01-22 19:28:12 发布
阅读量576 收藏 2
点赞数
分类专栏： C++asio服务器开发 文章标签： c++ boost asio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39885372/article/details/104080561
版权

如果服务器和客户端都是用C++语言写的就可以用序列化方法将数据存放到流或文件中
使用序列化C++设计消息协议具有以下优点：
1、用序列化方法还可以进行存盘和读盘，还可以进行版本控制
2、用序列化方式安全性会比reintepret_cast更高，也不用考虑大小端对齐之类的问题
3、与原始C结构体相比可以脱离pod类型的限制定义非常复杂的类，传输复杂的数据

缺点：
1、服务器和客户端语言都需要使用C++

以下是用boost序列化库写的一个例子：
可以用boost自带的serialization::access来使用序列化C++

序列化处理类：

//SerilizationObject.cpp
class SBindName {
private:
  friend class boost::serialization::access;
  // When the class Archive corresponds to an output archive, the
  // & operator is defined similar to <<.  Likewise, when the class Archive
  // is a type of input archive the & operator is defined similar to >>.
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar & m_bindName;
		//ar << m_bindName;
		//ar >> m_bindName;
  }
  std::string m_bindName;

public:
  SBindName(std::string name) : m_bindName(std::move(name)) {}
	SBindName() {}
  const std::string &bindName() const { return m_bindName; }
};

class SChatInfo {
  friend class boost::serialization::access;
  // When the class Archive corresponds to an output archive, the
  // & operator is defined similar to <<.  Likewise, when the class Archive
  // is a type of input archive the & operator is defined similar to >>.
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar &m_chatInformation;
  }
  std::string m_chatInformation;

public:
  SChatInfo(std::string info) : m_chatInformation(std::move(info)) {}
	SChatInfo() {}
  const std::string &chatInformation() const { return m_chatInformation; }
};

class SRoomInfo {
public:
	SRoomInfo() {}
  SRoomInfo(std::string name, std::string info)
      : m_bind(std::move(name)), m_chat(std::move(info)) {}
	const std::string& name() const { return m_bind.bindName();}
	const std::string& information() const { return m_chat.chatInformation();}
private:

  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int version) {
    ar &m_bind;
		ar & m_chat;
  }
	SBindName m_bind;
	SChatInfo m_chat;

};

#endif

SBindName m_bind和SChatInfo m_chat;定义成类可以直接进行序列化操作，可以脱离pod类型的限制，定义非常复杂的类
archive可以看成是文件或内存，是内存就可以通过tcp传输到客户端
&和<<,>>等价，表示数据写入

消息处理：

//structHeader.h
#ifndef FND_STRUCT_HEADER_H
#define FND_STRUCT_HEADER_H
#include <string>
struct Header {
	int bodySize;
	int type;
};

enum MessageType {
	MT_BIND_NAME = 1,
	MT_CHAT_INFO = 2,
	MT_ROOM_INFO = 3,
};

// client send
struct BindName {
	char name[32];
	int nameLen;
};

// client send
struct ChatInformation {
	char information[256];
	int infoLen;
};


// serversend
struct RoomInformation {
	BindName name;
	ChatInformation chat;
};

bool parseMessage(const std::string& input, int* type, std::string& outbuffer);
bool parseMessage2(const std::string& input, int* type, std::string& outbuffer);
#endif

//structHeader.cpp
#include "structHeader.h"
#include "SerilizationObject.h"
#include <cstdlib>
#include <cstring>
#include <iostream>
template <typename T> std::string seriliaze(const T &obj) {
  std::stringstream ss;
  boost::archive::text_oarchive oa(ss);
  oa & obj;
  return ss.str();
}

bool parseMessage2(const std::string& input, int* type, std::string& outbuffer) {
  auto pos = input.find_first_of(" ");
  if (pos == std::string::npos)
    return false;
  if (pos == 0)
    return false;
	// "BindName ok" -> substr -> BindName
  auto command = input.substr(0, pos);
  if (command == "BindName") {
    // we try to bind name
    std::string name = input.substr(pos + 1);
    if (name.size() > 32)
      return false;
    if (type)
      *type = MT_BIND_NAME;
    //SBindName bindInfo(std::move(name));
    outbuffer = seriliaze(SBindName(std::move(name)));
    return true;
  } else if (command == "Chat") {
    // we try to chat
    std::string chat = input.substr(pos + 1);
    if (chat.size() > 256)
      return false;
		outbuffer = seriliaze(SChatInfo(std::move(chat)));
//    ChatInformation info;
//    info.infoLen = chat.size();
//    std::memcpy(&(info.information), chat.data(), chat.size());
//    auto buffer = reinterpret_cast<const char *>(&info);
//    outbuffer.assign(buffer, buffer + sizeof(info));
    if (type)
      *type = MT_CHAT_INFO;
    return true;
  }
  return false;
}
// cmd messagebody
bool parseMessage(const std::string &input, int *type, std::string &outbuffer) {
  // input should be cmd body
  auto pos = input.find_first_of(" ");
  if (pos == std::string::npos)
    return false;
  if (pos == 0)
    return false;
	// "BindName ok" -> substr -> BindName
  auto command = input.substr(0, pos);
  if (command == "BindName") {
    // we try to bind name
    std::string name = input.substr(pos + 1);
    if (name.size() > 32)
      return false;
    if (type)
      *type = MT_BIND_NAME;
    BindName bindInfo;
    bindInfo.nameLen = name.size();
    std::memcpy(&(bindInfo.name), name.data(), name.size());
    auto buffer = reinterpret_cast<const char *>(&bindInfo);
    outbuffer.assign(buffer, buffer + sizeof(bindInfo));
    return true;
  } else if (command == "Chat") {
    // we try to chat
    std::string chat = input.substr(pos + 1);
    if (chat.size() > 256)
      return false;
    ChatInformation info;
    info.infoLen = chat.size();
    std::memcpy(&(info.information), chat.data(), chat.size());
    auto buffer = reinterpret_cast<const char *>(&info);
    outbuffer.assign(buffer, buffer + sizeof(info));
    if (type)
      *type = MT_CHAT_INFO;
    return true;
  }
  return false;
}

parseMessage2是序列化对数据操作，对oa的操作最终序化到ss流中

聊天消息类：

//chat_message.h
#ifndef CHAT_MESSAGE_HPP
#define CHAT_MESSAGE_HPP

#include "structHeader.h"
#include "SerilizationObject.h"

#include <iostream>

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
// s -> c   c -> s message { header, body } // header length

class chat_message {
public:
  enum { header_length = sizeof(Header) };
  enum { max_body_length = 512 };

  chat_message(){}

  const char *data() const { return data_; }

  char *data() { return data_; }

  std::size_t length() const { return header_length + m_header.bodySize; }

  const char *body() const { return data_ + header_length; }

  char *body() { return data_ + header_length; }
  int type() const { return m_header.type; }

  std::size_t body_length() const { return m_header.bodySize; }
  void setMessage(int messageType, const void *buffer, size_t bufferSize) {
    assert(bufferSize <= max_body_length);
		m_header.bodySize = bufferSize;
		m_header.type = messageType;
		std::memcpy(body(), buffer, bufferSize);
		std::memcpy(data(), &m_header, sizeof(m_header));
  }
	void setMessage(int messageType, const std::string& buffer) {
		setMessage(messageType, buffer.data(), buffer.size());
	}

  bool decode_header() {
    std::memcpy(&m_header, data(), header_length);
    if (m_header.bodySize > max_body_length) {
      std::cout << "body size " << m_header.bodySize << " " << m_header.type
                << std::endl;
      return false;
		}
    return true;
  }

private:
  char data_[header_length + max_body_length];
	Header m_header;
};

#endif // CHAT_MESSAGE_HPP

客户端代码部分：

//client.cpp
#include "chat_message.h"
#include "structHeader.h"
#include "SerilizationObject.h"

#include <boost/asio.hpp>

#include <deque>
#include <iostream>
#include <thread>

#include <cstdlib>
#include <cassert>

using boost::asio::ip::tcp;

using chat_message_queue = std::deque<chat_message>;


class chat_client {
public:
  chat_client(boost::asio::io_service &io_service,
              tcp::resolver::iterator endpoint_iterator)
      : io_service_(io_service), socket_(io_service) {
    do_connect(endpoint_iterator);
  }

  void write(const chat_message &msg) {
    io_service_.post([this, msg]() {
      bool write_in_progress = !write_msgs_.empty();
      write_msgs_.push_back(msg);
      if (!write_in_progress) {
        do_write();
      }
    });
  }

  void close() {
    io_service_.post([this]() { socket_.close(); });
  }

private:
  void do_connect(tcp::resolver::iterator endpoint_iterator) {
    boost::asio::async_connect(
        socket_, endpoint_iterator,
        [this](boost::system::error_code ec, tcp::resolver::iterator) {
          if (!ec) {
            do_read_header();
          }
        });
  }

  void do_read_header() {
    boost::asio::async_read(
        socket_,
        boost::asio::buffer(read_msg_.data(), chat_message::header_length),
        [this](boost::system::error_code ec, std::size_t /*length*/) {
          if (!ec && read_msg_.decode_header()) {
            do_read_body();
          } else {
            socket_.close();
          }
        });
  }

  void do_read_body() {
    boost::asio::async_read(
        socket_, boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),
        [this](boost::system::error_code ec, std::size_t /*length*/) {
          if (!ec) {
            if (read_msg_.type() == MT_ROOM_INFO) {
              SRoomInfo info;
              std::stringstream ss(
                  std::string(read_msg_.body(),
                              read_msg_.body() + read_msg_.body_length()));
              boost::archive::text_iarchive ia(ss);
              ia & info;
              std::cout << "client: '";
              std::cout << info.name();
              std::cout << "' says '";
              std::cout << info.information();
              std::cout << "'\n";
            }
            do_read_header();
          } else {
            socket_.close();
          }
        });
  }

  void do_write() {
    boost::asio::async_write(
        socket_, boost::asio::buffer(write_msgs_.front().data(),
                                     write_msgs_.front().length()),
        [this](boost::system::error_code ec, std::size_t /*length*/) {
          if (!ec) {
            write_msgs_.pop_front();
            if (!write_msgs_.empty()) {
              do_write();
            }
          } else {
            socket_.close();
          }
        });
  }

private:
  boost::asio::io_service &io_service_;
  tcp::socket socket_;
  chat_message read_msg_;
  chat_message_queue write_msgs_;
};

int main(int argc, char *argv[]) {
  try {
    if (argc != 3) {
      std::cerr << "Usage: chat_client <host> <port>\n";
      return 1;
    }

    boost::asio::io_service io_service;

    tcp::resolver resolver(io_service);
    auto endpoint_iterator = resolver.resolve({argv[1], argv[2]});
    chat_client c(io_service, endpoint_iterator);

    std::thread t([&io_service]() { io_service.run(); });

    char line[chat_message::max_body_length + 1];
		// ctrl-d
    while (std::cin.getline(line, chat_message::max_body_length + 1)) {
      chat_message msg;
			auto type = 0;
			std::string input(line, line + std::strlen(line));
			std::string output;
			if(parseMessage2(input, &type, output)) {
				msg.setMessage(type, output.data(), output.size());
				c.write(msg);
				std::cout << "write message for server " << output.size() << std::endl;
			}
    }

    c.close();
    t.join();
  } catch (std::exception &e) {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

通过stringstream将内存信息转化出来

服务器代码部分：

//main.cpp
#include "chat_message.h"

#include <boost/asio.hpp>

#include <deque>
#include <iostream>
#include <list>
#include <memory>
#include <set>
#include <utility>

#include <cstdlib>

using boost::asio::ip::tcp;

//----------------------------------------------------------------------

using chat_message_queue = std::deque<chat_message>;
using chat_message_queue2 = std::list<chat_message>;
//----------------------------------------------------------------------


//----------------------------------------------------------------------

class chat_session;
using chat_session_ptr = std::shared_ptr<chat_session>;
class chat_room {
public:
public:
	void join(chat_session_ptr);
	void leave(chat_session_ptr);
	void deliver(const chat_message&);
private:
  std::set<chat_session_ptr> participants_;
  enum { max_recent_msgs = 100 };
  chat_message_queue recent_msgs_;
};
//----------------------------------------------------------------------

class chat_session : public std::enable_shared_from_this<chat_session> {
public:
  chat_session(tcp::socket socket, chat_room &room)
      : socket_(std::move(socket)), room_(room) {}

  void start() {
    room_.join(shared_from_this());
    do_read_header();
  }

  void deliver(const chat_message &msg) {
		// first false
    bool write_in_progress = !write_msgs_.empty();
    write_msgs_.push_back(msg);
    if (!write_in_progress) {
			// first
      do_write();
    }
  }

private:
  void do_read_header() {
    auto self(shared_from_this());
    boost::asio::async_read(
        socket_,
        boost::asio::buffer(read_msg_.data(), chat_message::header_length),
        [this, self](boost::system::error_code ec, std::size_t /*length*/) {
          if (!ec && read_msg_.decode_header()) {
            do_read_body();
          } else {
            std::cout << "Player leave the room\n";
            room_.leave(shared_from_this());
          }
        });
  }

  void do_read_body() {
    auto self(shared_from_this());
    boost::asio::async_read(
        socket_, boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),
        [this, self](boost::system::error_code ec, std::size_t /*length*/) {
          if (!ec) {
            //room_.deliver(read_msg_);
						handleMessage();
            do_read_header();
          } else {
            room_.leave(shared_from_this());
          }
        });
  }

	template<typename T>
		T toObject() {
			T obj;
			std::stringstream ss(std::string(read_msg_.body(), read_msg_.body() + read_msg_.body_length()));
			boost::archive::text_iarchive oa(ss);
			oa & obj;
			return obj;
		}

  void handleMessage() {
    if (read_msg_.type() == MT_BIND_NAME) {
      // bind name
      // should first check message is ok
      // but we ignore now
//      const BindName *bind =
//          reinterpret_cast<const BindName *>(read_msg_.body());

      //m_name.assign(bind->name, bind->name + bind->nameLen);
//			SBindName bindName;
//			std::stringstream ss(std::string(read_msg_.body(), read_msg_.body() + read_msg_.body_length()));
//			boost::archive::text_iarchive oa(ss);
//			oa & bindName;
			auto bindName = toObject<SBindName>();
			m_name = bindName.bindName();
    } else if (read_msg_.type() == MT_CHAT_INFO) {
      // real chat
      // should first check message is ok
      // but we ignore now
//      const ChatInformation *chat =
//          reinterpret_cast<const ChatInformation *>(read_msg_.body());
//      m_chatInformation.assign(chat->information,
//                               chat->information + chat->infoLen);

//			SChatInfo chat;
//			std::stringstream ss(std::string(
//						read_msg_.body(), read_msg_.body_length()));
//			boost::archive::text_iarchive oa(ss);
//			oa & chat;

			auto chat = toObject<SChatInfo>();
			m_chatInformation = chat.chatInformation();

      auto rinfo = buildRoomInfo();
      chat_message msg;
      msg.setMessage(MT_ROOM_INFO, rinfo);
     // msg.setMessage(MT_ROOM_INFO, &rinfo, sizeof(rinfo));
      room_.deliver(msg);

    } else {
      // not valid msg do nothing
    }
  }

  void do_write() {
    auto self(shared_from_this());
    boost::asio::async_write(
        socket_, boost::asio::buffer(write_msgs_.front().data(),
                                     write_msgs_.front().length()),
        [this, self](boost::system::error_code ec, std::size_t /*length*/) {
          if (!ec) {
            write_msgs_.pop_front();
            if (!write_msgs_.empty()) {
              do_write();
            }
          } else {
            room_.leave(shared_from_this());
          }
        });
  }

  tcp::socket socket_;
  chat_room &room_;
  chat_message read_msg_;
  chat_message_queue write_msgs_;
	std::string m_name;
	std::string m_chatInformation;
	std::string buildRoomInfo() const {
		SRoomInfo roomInfo(m_name, m_chatInformation);
		std::stringstream ss;
		boost::archive::text_oarchive oa(ss);
		oa & roomInfo;
		return ss.str();
	}
//	RoomInformation buildRoomInfo() const {
//		RoomInformation info;
//		info.name.nameLen = m_name.size();
//		std::memcpy(info.name.name, m_name.data(), m_name.size());
//		info.chat.infoLen = m_chatInformation.size();
//		std::memcpy(info.chat.information, m_chatInformation.data(),
//				m_chatInformation.size());
//		return info;
//	}
};


  void chat_room::join(chat_session_ptr participant) {
    participants_.insert(participant);
    for (const auto& msg : recent_msgs_)
      participant->deliver(msg);
  }

  void chat_room::leave(chat_session_ptr participant) {
    participants_.erase(participant);
  }

  void chat_room::deliver(const chat_message &msg) {
    recent_msgs_.push_back(msg);
    while (recent_msgs_.size() > max_recent_msgs)
      recent_msgs_.pop_front();

    for (auto& participant : participants_)
      participant->deliver(msg);
  }


//----------------------------------------------------------------------

class chat_server {
public:
  chat_server(boost::asio::io_service &io_service,
              const tcp::endpoint &endpoint)
      : acceptor_(io_service, endpoint), socket_(io_service) {
    do_accept();
  }

private:
  void do_accept() {
    acceptor_.async_accept(socket_, [this](boost::system::error_code ec) {
      if (!ec) {
        auto session =
            std::make_shared<chat_session>(std::move(socket_), room_);
        session->start();
      }

      do_accept();
    });
  }

  tcp::acceptor acceptor_;
  tcp::socket socket_;
  chat_room room_;
};

//----------------------------------------------------------------------

int main(int argc, char *argv[]) {
  try {
    if (argc < 2) {
      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
      return 1;
    }

    boost::asio::io_service io_service;

    std::list<chat_server> servers;
    for (int i = 1; i < argc; ++i) {
      tcp::endpoint endpoint(tcp::v4(), std::atoi(argv[i]));
      servers.emplace_back(io_service, endpoint);
    }

    io_service.run();
  } catch (std::exception &e) {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}
昔拉天使
关注
专栏目录
《C++游戏服务器开发入门到掌握》boost库中的网络库asio
风铃飞弦的博客
07-10 2742
84、01 服务器编程一般的思路： 1、选择一个平台、熟悉API、构建框架；2、找一个成熟的框架，学习它。通过学习它掌握服务器编程方面的知识。 成熟的框架有很多，这里选用Asio网络库原因有：简单方便、作者写的代码比较规范、可能进入下一代的C++标准库中。 可移植性好： 在windows下可能使用iocp，在linux下可能使用epoll，在bsd下可能使用kqueue。 可扩展性高： 可以自己...
C++类型转换之reinterpret_cast
我的博客
06-20 1960
C++类型转换之reinterpret_cast
C/C++结构体序列化配置模板化
05-09
代码说明： http://blog.csdn.net/catxl313/article/details/25434275
C++实现结构体序列化和反序列化
qq_55967171的博客
10-30 2141
序列化：就是将对象转化成字节序列的过程。反序列化：就是讲字节序列转化成对象的过程。对象序列化成的字节序列会包含对象的类型信息、对象的数据等，说白了就是包含了描述这个对象的所有信息，能根据这些信息“复刻”出一个和原来一模一样的对象。简单的来说结构体序列化就是将这个结构体里的数据转成一段通用的数据，另一个同类型结构体拿到这段数据后可以反序列化拿到每个结构体成员的值。上述代码中将a的数据拷贝到b，当然像A这样简单的结构体直接=就能进行拷贝了。
[C++设计]如何设计支持网络序列化的类
sabolasi
08-04 156
一些对象为了能够很方便地在网络上进行传输，就需要支持序列化和反序列化。 如何设计一个易于序列化和反序列化的类呢？ MyClass{ public: int serialize(char* buf, const int64_t buf_len, int64_t&amp; pos) const; int deserialize(const char* buf, ...
C++ 消息序列化与反序列化
mmdev
07-31 668
1. 消息序列化 将具有一定结构的数据转换成可以存取或者可以传输的形式，比如转换成字符流的形式(char *)。通过序列化后，消息可以在系统各逻辑模块或者网络中传输。 2.消息反序列化 顾名思义，反序列化与序列化的过程相反。例如，将网络中传过来的放在缓冲区的字节流数据(char *)解码成具有一定含义和结构的数据，然后便可以对接出来的数据进行处理。 3.实例 3.1) 序列...
C语言 结构体 序列化
qq_28808697的博客
12-01 1770
# include <stdio.h> int main() { struct point { int x; int y; } p; p.x = 50; p.y = 128; // p_char 指向结构体变量p， 并将p识别成 无符号char类型 unsigned char *p_char = (unsigned char *) &p; printf("%d\n", sizeof(.
用原始时代的C结构设计消息协议(C++asio网络库相关）
01-20
在大多数现代网络应用中，更推荐使用如protobuf、Cap'n Proto等序列化库，或者直接使用JSON、XML等文本格式来定义更灵活、易扩展且跨语言兼容的消息协议。这些现代方法可以更好地处理复杂数据，解决大小端问题，并...
Boost程序库探秘——深度解析C++准标准库
04-24
此外，书中还深入讲解了Boost库中的其他重要组件，如Boost.Serialization用于序列化和反序列化，Boost.Date_Time处理日期和时间，Boost.Locale进行国际化和本地化操作，以及Boost.Filesystem简化文件系统操作等。...
超越c++标准库——boost程序库导论
09-25
《超越C++标准库——Boost程序库导论》是一本深度探讨C++开发中的Boost库的专著。Boost库是C++社区公认的扩展标准库，它包含了大量的高效、高质量的可重用C++组件，旨在提升C++的灵活性、效率和可移植性。这本书面向...
C++ 实现序列化
11-03
C++实现序列化，简单的讲是将C++里的对象（此处是广义上的对象，内置类型或者用户自定义类型）数据变成char*，即单个字节的数据，这样方便传输等，涉及到的知识点有C++中的函数重载，操作符重写，allcotor，左值和右值，继承，模板等
【C++】带指针结构体的序列化操作
K2016_04_16的博客
01-07 792
在项目中经常会遇到结构体中含指针的读写，指针保存的是某块内存的地址，其读写方式和基础变量存在差异，本文介绍的是使用fwrite和fread读取结构体信息。
C++结构体序列化和反序列化方法
昔拉的博客
05-15 4057
unsigned char* EncodeCommonStruct(const CommonStruct_st& CommonSt) { //分配内存 unsigned char* strBuff = (unsigned char*)malloc(CALC_COMMON_ST_LEN(&CommonSt)); if (NULL == strBuff) { return NULL; } //填充内容 *(long*)s
C++序列化（转）
weixin_30268071的博客
05-11 109
实现序列化的类必须满足下列条件：1. 该类需要从CObject类派生（可以是间接派生）；2. 在类中中进行DECLARE_SERIAL宏定义；3. 类存在有缺省的构造函数；4. 类中实现了Serialize()函数，并且在其中调用基类的序列化函数；5. 使用IMPLEMENT_SERIAL宏指明类名及版本号；C/C++ code .h struct Node { int...
c++的struct结构体的序列化和反序列化和json的序列化和反序列化的通俗直白的解释和说明
最新发布
dz131lsq的博客
01-22 1042
序列化转换成字节流，能方便的进行保持和在网络进行传输。反序列化能把字节流数据转换成结构化的数据，方便读取和识别。首先要明白一个概念，如果用int*指针对，一块内存进行遍历这个指针每次加1实际上是向前移动4个字节，类似的shor*每次移动2个字节，BYTE*每次移动一个字节。
C++与序列化
weixin_43728590的博客
06-15 3810
协议/protobuf
C++序列化：超越结构体的高效消息协议设计
在C++编程中，当服务器和客户端都采用C++语言时，序列化是一种有效的方法来设计和实现消息协议，特别是在使用如ASIO（Asynchronous I/O）这样的网络库时。序列化的优势在于： 1. 数据持久化与版本控制：通过序列化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值