跨平台Socket封装——CSocketImpl类

最新推荐文章于 2024-06-19 19:10:12 发布
最新推荐文章于 2024-06-19 19:10:12 发布
阅读量871 收藏
点赞数 1
分类专栏： C/C++ 文章标签： socket 跨平台
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/declarefly/article/details/53332178
版权

头文件SocketImpl.h

namespace LinWin
{
    class CSocketImpl
    {
    private:
        net_socket_fd m_sock;
        bool          m_bBlocking;

    public:
        CSocketImpl();
        CSocketImpl(net_socket_fd sockfd);
        CSocketImpl(const CSocketImpl& iml);
        virtual ~CSocketImpl();

    public:
        virtual int Create(int af = AF_INET, int type = SOCK_STREAM, int proto = 0);

        virtual void Close();

        virtual int Bind(const CSocketAddress& address);

        virtual int Listen(int backlog = 64);

        virtual int Accept(CSocketImpl* connfd, CSocketAddress& clientAddr);

        virtual int Connect(const CSocketAddress& addr);

        virtual int SendBytes(const void* lpBuf, unsigned int lpLen, int flag = 0);
        virtual int RecvBytes(void* lpBuf, unsigned int lpLen, int flag = 0);

        virtual int SendBytesto(const void* lpBuf, unsigned int lpLen, const CSocketAddress& addr, int flag = 0);
        virtual int RecvBytesfrom(void* lpBuf, unsigned int lpLen, CSocketAddress& addr, int flag = 0);

        virtual int ShutdownReceive();
        virtual int ShutdownSend();
        virtual int Shutdown();

        virtual int SetSendBufferSize(int size);
        virtual int GetSendBufferSize(int& size);

        virtual int SetReceiveBufferSize(int size);
        virtual int GetReceiveBufferSize(int& size);

        virtual int LocalAddress(CSocketAddress& localAddr);
        virtual int RemoteAddress(CSocketAddress& remoteAddr);

        virtual int Available(int& result);

        int SetOption(int level, int option, int value);
        int SetOption(int level, int option, unsigned value);
        int SetOption(int level, int option, unsigned char value);
        virtual int SetRawOption(int level, int option, const void* value, int length);

        int GetOption(int level, int option, int& value);
        int GetOption(int level, int option, unsigned& value);
        int GetOption(int level, int option, unsigned char& value);
        virtual int GetRawOption(int level, int option, void* value, int length);

        int SetLinger(bool on, int seconds);
        int GetLinger(bool& on, int& seconds);

        int SetNoDelay(bool flag);
        int GetNoDelay(bool& flag);

        int SetKeepAlive(bool flag);
        int GetKeepAlive(bool& flag);

        int SetReuseAddress(bool flag);
        int GetReuseAddress(bool& flag);

        virtual int SetBlocking(bool flag);
        virtual bool GetBlocking() const;

        net_socket_fd Sockfd() const;
        const net_socket_fd* Handle() const
        {
            return reinterpret_cast<const net_socket_fd*>(&m_sock);
        }

        int SocketError();

        virtual int Ioctl(net_ioctl_request_t request, int& arg);
        virtual int Ioctl(net_ioctl_request_t request, void* arg);
    }
}

Socket网络编程最基本的操作都封装在这里了，随后再把扩展的加进来。net_socket_fd类型的定义是为了统一平台之间的差异，它的定义已在platform.h文件中更新（在之前博客中）。

SocketImpl.cpp文件

#include "SocketImpl.h"

LinWin::CSocketImpl::CSocketImpl() : m_sock(NET_INVALID_SOCKET), m_bBlocking(false)
{

}

LinWin::CSocketImpl::CSocketImpl(net_socket_fd sock) : m_sock(sock), m_bBlocking(false)
{

}

LinWin::CSocketImpl::CSocketImpl(const CSocketImpl& iml) : m_sock(iml.m_sock), m_bBlocking(iml.m_bBlocking)
{

}

LinWin::CSocketImpl::~CSocketImpl()
{
    Close();
}

int LinWin::CSocketImpl::Create(int af /* = AF_INET */, int type /* = SOCK_STREAM */, int proto /* = 0 */)
{
    m_sock = ::socket(af, type, proto);

    return m_sock == NET_INVALID_SOCKET ? -1 : 0;
}

void LinWin::CSocketImpl::Close()
{
    if (m_sock != NET_INVALID_SOCKET)
    {
        closesocket(m_sock);
        m_sock = NET_INVALID_SOCKET;
    }
}

int LinWin::CSocketImpl::Bind(const CSocketAddress& address)
{
    if (m_sock == NET_INVALID_SOCKET)
        return -2;

    if (::bind(m_sock, reinterpret_cast<const struct sockaddr *>(address.GetAddress()), address.AddressLength()) != 0)
        return -1;

    return 0;
}

int LinWin::CSocketImpl::Listen(int backlog /* = 64 */)
{
    if (m_sock == NET_INVALID_SOCKET)
        return -2;

    if (::listen(m_sock, backlog) != 0)
        return -1;

    return 0;
}

int LinWin::CSocketImpl::Accept(CSocketImpl* connfd, CSocketAddress& clientAddr)
{
    if (m_sock == NET_INVALID_SOCKET || connfd == NULL)
        return -2;

    socklen_t salen = clientAddr.AddressLength();
    connfd->m_sock = ::accept(m_sock, reinterpret_cast<struct sockaddr*>(clientAddr.GetAddress()), &salen);
    if (connfd->m_sock == NET_INVALID_SOCKET)
        return -1;

    return 0;
}

int LinWin::CSocketImpl::Connect(const CSocketAddress& addr)
{
    if (m_sock == NET_INVALID_SOCKET)
        return -2;

    if (::connect(m_sock, reinterpret_cast<const struct sockaddr *>(addr.GetAddress()), addr.AddressLength()) != 0)
        return -1;

    return 0;
}

int LinWin::CSocketImpl::SendBytes(const void* lpBuf, unsigned int lpLen, int flag)
{
    return ::send(m_sock, reinterpret_cast<const char*>(lpBuf), lpLen, flag);
}

int LinWin::CSocketImpl::RecvBytes(void* lpBuf, unsigned int lpLen, int flag)
{
    return ::recv(m_sock, reinterpret_cast<char*>(lpBuf), lpLen, flag);
}

int LinWin::CSocketImpl::SendBytesto(const void* lpBuf, unsigned int lpLen, const CSocketAddress& addr, int flag)
{
    return ::sendto(m_sock, reinterpret_cast<const char*>(lpBuf), lpLen, flag,
        reinterpret_cast<const struct sockaddr*>(addr.GetAddress()), addr.AddressLength());
}

int LinWin::CSocketImpl::RecvBytesfrom(void* lpBuf, unsigned int lpLen, CSocketAddress& addr, int flag)
{
    socklen_t addrLen = addr.AddressLength();
    return ::recvfrom(m_sock, reinterpret_cast<char*>(lpBuf), lpLen, flag, 
        reinterpret_cast<sockaddr*>(addr.GetAddress()), &addrLen);
}

int LinWin::CSocketImpl::ShutdownReceive()
{
    return (::shutdown(m_sock, SD_RECEIVE) != 0) ? -1 : 0;
}

int LinWin::CSocketImpl::ShutdownSend()
{   
    return (::shutdown(m_sock, SD_SEND) != 0) ? -1 : 0;
}

int LinWin::CSocketImpl::Shutdown()
{
    return (::shutdown(m_sock, SD_BOTH) != 0) ? -1 : 0;
}

int LinWin::CSocketImpl::SetSendBufferSize(int size)
{
    return SetOption(SOL_SOCKET, SO_SNDBUF, size);
}

int LinWin::CSocketImpl::GetSendBufferSize(int& size)
{
    return GetOption(SOL_SOCKET, SO_SNDBUF, size);
}

int LinWin::CSocketImpl::SetReceiveBufferSize(int size)
{
    return SetOption(SOL_SOCKET, SO_RCVBUF, size);
}

int LinWin::CSocketImpl::GetReceiveBufferSize(int& size)
{
    return GetOption(SOL_SOCKET, SO_RCVBUF, size);
}

int LinWin::CSocketImpl::LocalAddress(CSocketAddress& localAddr)
{
    socklen_t saLen = sizeof(struct sockaddr_in);
    int rc = ::getsockname(m_sock, reinterpret_cast<struct sockaddr*>(localAddr.GetAddress()), &saLen);

    return rc != 0 ? -1 : 0;
}

int LinWin::CSocketImpl::RemoteAddress(CSocketAddress& remoteAddr)
{
    socklen_t saLen = sizeof(struct sockaddr_in);
    int rc = ::getpeername(m_sock, reinterpret_cast<struct sockaddr*>(remoteAddr.GetAddress()), &saLen);

    return rc != 0 ? -1 : 0;
}

int LinWin::CSocketImpl::Available(int& result)
{
    return Ioctl(FIONREAD, result);
}

int LinWin::CSocketImpl::SetOption(int level, int option, int value)
{
    return SetRawOption(level, option, &value, sizeof(value));
}

int LinWin::CSocketImpl::SetOption(int level, int option, unsigned value)
{
    return SetRawOption(level, option, &value, sizeof(value));
}

int LinWin::CSocketImpl::SetOption(int level, int option, unsigned char value)
{
    return SetRawOption(level, option, &value, sizeof(value));
}

int LinWin::CSocketImpl::SetRawOption(int level, int option, const void* value, int length)
{
    int rc = ::setsockopt(m_sock, level, option, reinterpret_cast<const char*>(value), (socklen_t)length);

    return rc == -1 ? -1 : 0;
}

int LinWin::CSocketImpl::GetOption(int level, int option, int& value)
{
    return GetRawOption(level, option, &value, sizeof(value));
}

int LinWin::CSocketImpl::GetOption(int level, int option, unsigned& value)
{
    return GetRawOption(level, option, &value, sizeof(value));
}

int LinWin::CSocketImpl::GetOption(int level, int option, unsigned char& value)
{
    return GetRawOption(level, option, &value, sizeof(value));
}

int LinWin::CSocketImpl::GetRawOption(int level, int option, void* value, int length)
{
    int rc = ::getsockopt(m_sock, level, option, reinterpret_cast<char*>(value), reinterpret_cast<socklen_t*>(&length));

    return rc == -1 ? -1 : 0;
}

int LinWin::CSocketImpl::SetLinger(bool on, int seconds)
{
    struct linger l;
    l.l_onoff = on ? 1 : 0;
    l.l_linger = seconds;
    return SetRawOption(SOL_SOCKET, SO_LINGER, &l, sizeof(l));
}

int LinWin::CSocketImpl::GetLinger(bool& on, int& seconds)
{
    struct linger l;
    int len = sizeof(l);
    int ret = GetRawOption(SOL_SOCKET, SO_LINGER, &l, len);
    if (ret == 0)
    {
        on = (l.l_onoff != 0);
        seconds = l.l_linger;
    }

    return ret;
}

int LinWin::CSocketImpl::SetNoDelay(bool flag)
{
    int value = flag ? 1 : 0;
    return SetOption(IPPROTO_TCP, TCP_NODELAY, value);
}

int LinWin::CSocketImpl::GetNoDelay(bool& flag)
{
    int value = 0;
    int ret = GetOption(IPPROTO_TCP, TCP_NODELAY, value);
    if (ret == 0)
        flag = (value != 0);

    return ret;
}

int LinWin::CSocketImpl::SetKeepAlive(bool flag)
{
    int value = flag ? 1 : 0;
    return SetOption(SOL_SOCKET, SO_KEEPALIVE, value);
}

int LinWin::CSocketImpl::GetKeepAlive(bool& flag)
{
    int value(0);
    int ret = GetOption(SOL_SOCKET, SO_KEEPALIVE, value);
    if (ret == 0)
        flag = (value != 0);

    return ret;
}

int LinWin::CSocketImpl::SetReuseAddress(bool flag)
{
    int value = flag ? 1 : 0;
    return SetOption(SOL_SOCKET, SO_REUSEADDR, value);
}

int LinWin::CSocketImpl::GetReuseAddress(bool& flag)
{
    int value(0);
    int ret = GetOption(SOL_SOCKET, SO_REUSEADDR, value);
    if (ret == 0)
        flag = (value != 0);

    return ret;
}

int LinWin::CSocketImpl::SetBlocking(bool flag)
{
#ifdef WINDOWS_FAMILY
    unsigned long nonblocking = flag ? 1 : 0;
    if (ioctlsocket(m_sock, FIONBIO, (unsigned long*)&nonblocking) == SOCKET_ERROR)
        return -1;
#else
    int opts;
    opts = fcntl(m_sock, F_GETFL);
    if (opts < 0)
        return -1;
    if (flag)
        opts = opts | O_NONBLOCK;
    else
        opts = opts & (~O_NONBLOCK);
    if (fcntl(m_sock, F_SETFL, opts) < 0)
        return -1;
#endif
    m_bBlocking = flag;

    return 0;
}

bool LinWin::CSocketImpl::GetBlocking() const
{
    return m_bBlocking;
}

net_socket_fd LinWin::CSocketImpl::Sockfd() const
{
    return m_sock;
}

int LinWin::CSocketImpl::Ioctl(net_ioctl_request_t request, int& arg)
{
    int rc;
#ifdef WINDOWS_FAMILY
    rc = ioctlsocket(m_sock, request, reinterpret_cast<u_long*>(&arg));
#else
    rc = ::ioctl(m_sock, request, &arg);
#endif

    return (rc != 0) ? -1 : 0;
}

int LinWin::CSocketImpl::Ioctl(net_ioctl_request_t request, void* arg)
{
    int rc;
#ifdef WINDOWS_FAMILY
    rc = ioctlsocket(m_sock, request, reinterpret_cast<u_long*>(arg));
#else
    rc = ::ioctl(m_sock, request, arg);
#endif

    return (rc != 0) ? -1 : 0;
}

int LinWin::CSocketImpl::SocketError()
{
#ifdef WINDOWS_FAMILY
    return GetLastError();
#else
    return errno;
#endif
}

由于CSocketAddress类中添加了一个非const版本的GetAddress成员函数，所以去掉此类中所有const_cast的转换。

路遇天使
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
调研跨平台C++网络库
caolinqing1的专栏
05-26 1925
(1)ACE 庞大、复杂，适合大型项目。开源、免费，不依赖第三方库，支持跨平台。 http://www.cs.wustl.edu/~schmidt/ACE.html (2)Asio Asio基于Boost开发的异步IO库，封装了Socket，简化基于socket程序的开发。 开源、免费，支持跨平台。 http://think-async.com/ (3)POCO POCO C++ Libraries 提供一套 C++ 的类库用以开发基于网络的可移植的应用程序，功能涉及线程、线程同..
C/C++封装socket通信类
ymxyld的博客
05-17 3706
不管是socket通信程序的客户端还是服务端，准备工作的代码又长又难看占地方，影响了主程序的结构，必须分离出来。 一、C的封装方法 C语言只能把程序代码封装成函数。 1、客户端 把客户端连接服务端的socket操作封装到connecttoserver函数中，主程序的代码更简洁。 // TCP客户端连服务端的函数，serverip-服务端ip，port通信端口 // 返回值：成功返回已连接socket，失败返回-1。 int connecttoserver(const char *serverip,const
htons函数详解
科技浪人
08-05 3162
Part 1: htons函数具体解释 在Linux和Windows网络编程时需要用到htons和htonl函数，用来将主机字节顺序转换为网络字节顺序。 在Intel机器下，执行以下程序 int main() …{ printf(“%d /n”,htons(16)); return 0; } 得到的结果是4096，初一看感觉很怪。解释如下，数字16的16进制表
C++跨平台socket编程
最新发布
qq_24867003的博客
06-19 1240
跨平台socket
OpenSocket做超简单易用的跨平台高性能网络并发库
linyouhappy的博客
03-05 605
OpenSocket是一个超简单易用的跨平台高性能网络并发库。 结合OpenThread使用，可以轻轻构建在任意平台（包括移动平台）构建高性能并发服务器。 OpenSocket全平台设计，无其他依赖，只有4个源文件，让小白都可以轻松玩转C++高性能网络并发开发。
C++ socket 基本功能跨平台封装（好用）
12-06
真正可以使用的平台无关性的 C++ socket wrapper，没有做任何多余的事情，仅仅对 socket 的基本功能进行了平台无关性的封装，简洁原生。封装了：setoption, connect, close, send, recv, sendto, recvfrom， accept...
跨平台socket封装
04-12
标题中的“跨平台socket封装”指的是在不同的操作系统上（如Windows、Linux、macOS等）实现网络通信的接口标准化，以便编写的应用程序可以在多种平台上运行。Socket是操作系统提供的一种网络编程接口，它允许应用...
C++自定义封装socket操作业务类完整实例
08-29
本实例提供了在Linux环境下实现C++自定义封装socket操作业务类的详细过程，允许开发者轻松地创建socket连接、设置参数以及发送请求。 首先，`SocketConnector` 类是核心业务类，它包含了与socket相关的各种操作。类...
跨平台socket demo
05-14
windows xp下使用apache.mina2框架搭建socket服务器，客户端在苹果系统下用c来实现的，因为用AsyncSocket框架无法正常与服务器交互，不知问题出在哪里，只好使用c了。 demo里包含windows下socket服务器、客户端工程...
C# socket封装类和组件含例程全部开源
06-17
本资源“C# socket封装类和组件含例程全部开源”提供了一套全面且强大的C# Socket封装，旨在简化开发过程，提高代码的可读性和可维护性。以下是对这个开源项目的详细解析： 首先，Socket是TCP/IP协议族的基本组成...
java-socket-platformer
03-26
java-socket-platformer
EasySocket:将Windows和Linux的socket库的使用封装成跨平台的类库，轻松使用socket创建连接
05-16
EasySocket 将Windows和Linux的socket库的使用封装成跨平台的类库，轻松使用socket。 组成 使用basicsocket 使用基础套接字库库，非常易用！ 使用： #include"EasySocket.h" 调用： using namespace SocketLib; ListeningSocket lsock; DataSocket dsock; lsock.Listen(5000);//在5000端口开始jiant dsock = lsock.Accept();//等待流入连接 只有5行代码就完成了Socket API的几十行代码的工作， 封装了socket为人诟病的历史接口等， 代码执行后dsock将包含一个套接字（如果有客户机与我们相连了的话），我们可以向客户机发送数据，并接受客户机的数据： char buffer[128] = "Hello clent
c++ socket类封装(udp/tcp)
11-20
类c++封装的一个socket类，对新手还是有点帮助
跨平台(Windows+Linux)的Socket通讯程序（一）—底层封装
guxch的专栏
03-30 3万+
【摘要】编写Socket通讯程序是一个老话题。本文重点介绍Windows平台和Linux平台Socket通讯的不同，采用C++，编制了一个简单的跨平台的Socket通讯库。 一、Socket通讯的基础知识 Socket通讯是两个计算机之间最基本的通讯方法，有TCP和UDP两种协议。关于这两种协议的区别，不少文章已有详述，这里，稍微总结一下： 1.TCP是面向连接的，是“流”式的，意即通讯两端
android.net.LocalSocketImpl.java
lifeqiuzhi521的博客
06-13 1047
/* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * Yo...
第八讲　Java网络编程
热门推荐
心蓝
09-13 3万+
课前索引课前思考　　1. 什么是TCP/ IP协议？　　2. TCP/IP有哪两种传输协议,各有什么特点？　　3. 什么是URL？　　4. URL和IP地址有什么样的关系？　　5. 什么叫套接字（Socket）？　　6. 套接字（Socket）和TCP/IP协议的关系？　　7. URL和套接字（Socket）的关系？8．1 网络编程基本概念，TCP/IP协议简介8.1.1 网络基础知识
三步学会Java Socket编程
Ninth（天下第九）的专栏
09-17 1564
1.什么是socket　　所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。　　以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这
Socket 类 构造函数和常见方法
稚枭天卓
01-24 7704
Socket类的构造函数如下： Socket()           通过系统默认类型的 SocketImpl 创建未连接套接字     Socket(InetAddress address, int port)           创建一个流套接字并将其连接到指定 IP 地址的指定端口号。     Socket(InetAddress host, int port, boolean
c++ 跨平台socket 封装
06-21
### 回答1： 跨平台socket封装是指为了在不同操作系统或者硬件平台上运行的应用程序之间进行网络通信，将socket API进行封装，提供统一的接口来使得应用程序可以方便地进行网络通信。由于在不同操作系统或者硬件平台上，socket API的实现方式有所不同，因此需要对不同平台进行适配和封装。跨平台socket封装的目的是方便开发人员进行网络通信，同时提高应用程序的可移植性、兼容性和可扩展性。在跨平台socket封装中，可以使用一些开源的第三方库，比如Boost.Asio、libevent等。这些第三方库提供了一些封装接口，使得应用程序能够使用统一的方式来进行网络编程。 在使用跨平台socket封装时，需要注意以下几点： 1.不同操作系统之间可能存在差异，需要进行相应的适配和兼容性测试。 2.在进行网络通信时，要保证通信协议的一致性，避免数据传输出现丢包或者粘包等问题。 3.要充分理解每个函数的含义和参数，以保证网络编程的正确性和可靠性。 总之，跨平台socket封装为应用程序提供了简单、方便、可移植的网络编程方式，是现代网络通信的重要组成部分。 ### 回答2： 跨平台socket封装是一种将不同操作系统的socket细节进行封装的技术。通过跨平台socket封装，我们可以让不同操作系统的socket代码在不进行修改的情况下在不同的平台上运行。这样可以加快开发者的开发速度，同时降低代码维护难度。 跨平台socket封装技术的实现需要解决两个问题：一是不同操作系统对socket函数的实现细节不同，导致代码实现难度大，需要针对每个操作系统单独编写代码；二是跨平台socket封装技术需要充分考虑移植性问题，需要确保在不同操作系统和硬件平台上稳定运行。 为了解决这些问题，跨平台socket封装技术通常采用C或C++语言编写，使用平台无关的API，例如POSIX API或者Winsock API。同时，跨平台socket封装也需要具备跨平台的编译和构建环境，例如常用的Cmake或者Autotools。 跨平台socket封装的好处是显而易见的，它不仅可以提高开发者的效率，还可以降低代码维护的难度。但是需要注意的是，跨平台socket封装并不是万能的，它需要根据实际应用场景进行选择。如果仅仅是针对特定平台开发应用，使用原生的socket API可能更加简单有效。但是在开发跨平台应用或者框架时，使用跨平台socket封装技术是非常重要的。 ### 回答3： 跨平台socket封装是一种将底层的socket通信接口进行封装，使得在不同的操作系统以及开发语言中实现socket通信更加简单和便捷的工具。封装后的跨平台socket可以隐藏底层操作系统的差异性，以统一的接口供用户使用，提高了代码的可复用性和跨平台移植性。 跨平台socket的封装可以通过使用库的方式进行实现，例如常见的Socket.io和Boost.asio库等。这些库提供了高层次的API，使得开发者不再需要关注不同平台和语言下socket通信的实现细节，而是可以直接调用封装好的API进行开发。同时，这些库也提供了众多的工具和函数，能够帮助开发者更加便捷的进行socket通信的开发和调试。 跨平台socket封装的优点不仅在于提高编程效率，还可以提高系统的灵活性和可扩展性。开发者可以更加方便地进行平台切换和升级，同时还可以通过简单的调用来实现多个设备之间的通信。 总之，跨平台socket封装的出现大大方便了软件开发工作，能够满足当今多样化、交互性强的移动互联网市场需求，为开发者提供了高效、可靠的网络通信解决方案。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值