LINUX系统编程__网络编程

最新推荐文章于 2024-08-06 21:58:12 发布
最新推荐文章于 2024-08-06 21:58:12 发布
阅读量85 收藏
点赞数
文章标签： 网络 linux 服务器 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71775222/article/details/129026043
版权

进程间的通讯依赖于Linux内核，缺陷：无法多机通讯

Linux网络编程：

地址：IP地址、端口号；

数据：协议（数据格式）：http、TCP/UDP客户端：ftp、http、socket

socket套接字 ：TCP：面向连接（可靠）；UDP：面向报文（不太可靠），数据量大，如视频

TCP/UDP的对比：

端口号的作用：

一台拥有IP地址的主机可以提供许多服务，比如web服务、FTP服务、SMTP服务等

这些服务完全可以通过一个IP来实现。主机是怎样区分不同的网络服务的？显然不能只靠IP地址，因为IP地址与网络服务的关系是一对多的关系。

实际上是通过IP地址加端口号来区分不同的服务的

端口通过了一种访问通道

服务器一般都是通过知名端口号来识别的。例如对于某个TCP/IP来说，FTP服务器的TCP端口号都是21，每个Telnet服务器的端口号都是23，每个TFTP（简单文件传输协议）服务器的UDP端口号都是69。

字节序：

字节序是指多字节数据在计算机内存中储存或者网络传输时各字节的储存顺序。

常见序：

Little endian 小端字节序：将低字节储存在起始地址

Big endian 大端字节序：将高字节储存在起始地址

网络字节序 = 大端字节序

字节序转换API

#include <arpa/inet.h>
uint16_t htons(uint16_t host16bitvalue);//返回网络字节序的值
uint32_t htonl(uint32_t host32bitvalue);//返回网络字节序的值
uint16_t ntohs(uint16_t net16bitvalue);//返回主机字节序的值
uint32_t ntohl(uint32_t net32bitvable);//返回主机字节序的值

h代表host，n代表net，s代表short（两个字节），l代表long（4个字节），通过上面的四个函数可以实现主机字节序和网络字节序之间的转换。有时可以用INASDDR_ANY,INADDR_ANY指定地址操作系统自己获取。

socket编程(服务器)

socket核心函数

#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>

int socket(int domain,int type,int protocl);
int bind(int sockfd,const struct sockaddr*my_addr,socklen_t addrlen);
int listen(int sockfd,int backlog);
int accept(int sockfd,struct sockaddr*addr,socklen_t*addlen);
int connect(int sockfd,const struct sockaddr*serv_addr,socklen_t addrlen);
int close(int fd);

1.指定连接协议（socket();）

2.地址准备好（bind();）

地址API转换

3.监听(listen();)

4.连接(accept();)

数据收发常用的第二套API

客户端的connect函数

服务端、客户端代码

服务端框架

telnet+IP+端口号进行连接

server.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>       
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
int main()
{
        int s_fd;
        int n_read;
        char readBuf[128];
        char *msg = "I get your connect!";
        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;

        memset(&s_addr,0,sizeof(struct sockaddr_in));
        memset(&c_addr,0,sizeof(struct sockaddr_in));
        //1.int socket(int domain, int type, int protocol);
        //创建一个socket
        s_fd = socket(AF_INET,SOCK_STREAM,0);
        if(s_fd == -1){
                perror("scoket");
                exit(-1);
        }
        //设置socket地址
        s_addr.sin_family = AF_INET;    //地址族：使用IPv4
        s_addr.sin_port = htons(8989);    //端口号，使用网络字节序表示
        inet_aton("192.168.66.66",&s_addr.sin_addr);    //IP地址v4地址，用网络字节序表示
        /*struct sockaddr_in
        {
        sa_family_t sin_family;    //地址族:AF_INET
        u_int16_t sin_port;        //端口号,要使用网络字节序表示
        struct in_addr sin_addr;   //IPv4地址结构体
        char sin_zero[8];          //不使用
        }
        struct in_addr
        {
            u_int32_t s_addr;   //IPv4地址,要用网络字节序表示
        }*/

        //分配地址信息,socket命名
        //2.int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

        //创建一个监听队列
        //3.int listen(int sockfd, int backlog);
        listen(s_fd,10);
        //连接
        //4.int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
        int clen = sizeof(struct sockaddr_in);    //大小
        int c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);    //强制转换，不然会有警告
        if(c_fd == -1){
                perror("accept");
        }
        printf("get connect:%s\n",inet_ntoa(c_addr.sin_addr));
        
        //读取
        //5.read
        n_read = read(c_fd,readBuf,128);
        if(n_read == -1){
                perror("read");
        }else{
                printf("get message:%d,%s\n",n_read,readBuf);
        }
        
        //写入
        //6.write
        write(c_fd,msg,strlen(msg));
        //7.close
        close(s_fd);    //关闭
        close(c_fd);

        return 0;
}

客户端框架

client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
int main()
{
        int c_fd;
        int n_read;
        char readBuf[128];
        char *msg = "msg from client!";
        struct sockaddr_in c_addr;

        memset(&c_addr,0,sizeof(struct sockaddr_in));
        //1.int socket(int domain, int type, int protocol);

        c_fd = socket(AF_INET,SOCK_STREAM,0);
        if(c_fd == -1){
                perror("scoket");
                exit(-1);
        }

        c_addr.sin_family = AF_INET;
        c_addr.sin_port = htons(8989);
        inet_aton("192.168.31.41",&c_addr.sin_addr);

        /*struct sockaddr_in
                {
        sa_family_t sin_family;    //地址族:AF_INET
        u_int16_t sin_port;        //端口号,要使用网络字节序表示
        struct in_addr sin_addr;   //IPv4地址结构体
        char sin_zero[8];          //不使用
                }
        struct in_addr
        {
        u_int32_t s_addr;   //IPv4地址,要用网络字节序表示
        }*/
        
        //客户端不需要绑定和监听,直接连接服务器
        //2. int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr)) == -1){    //连接
                perror("connect");
                exit(-1);
        }
        //3.send
        write(c_fd,msg,strlen(msg));
        //4.read
        n_read = read(c_fd,readBuf,128);
        if(n_read == -1){
                perror("read");
        }else{
                printf("get message from client : %d,%s\n",n_read,readBuf);
        }
        //5.close
        //关闭连接
        close(c_fd);
        return 0;
}

实现双方聊天

TCP服务端

server.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
int main(int argc,char **argv)    //传参   ./server IP 端口号
{
        int s_fd;
        int c_fd;
        int n_read;
        char readBuf[128] = {0};
        //char *msg = "I get your connect!";
        char msg[128] = {0};
        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;

        if(argc != 3){
                printf("param is not good\n");
                exit(-1);
        }
        memset(&s_addr,0,sizeof(struct sockaddr_in));
        memset(&c_addr,0,sizeof(struct sockaddr_in));
        //1.int socket(int domain, int type, int protocol);
        //创建一个socket
        s_fd = socket(AF_INET,SOCK_STREAM,0);
        if(s_fd == -1){
                perror("scoket");
                exit(-1);
        }
        //设置socket地址
        s_addr.sin_family = AF_INET;    //地址族：使用IPv4
        s_addr.sin_port = htons(atoi(argv[2]));    //端口号，使用网络字节序表示,atoi()将ASCII强制转换为int
        inet_aton(argv[1],&s_addr.sin_addr);    //IP地址v4地址，用网络字节序表示

        /*struct sockaddr_in
                {
        sa_family_t sin_family;    //地址族:AF_INET
        u_int16_t sin_port;        //端口号,要使用网络字节序表示
        struct in_addr sin_addr;   //IPv4地址结构体
        char sin_zero[8];          //不使用
                }
        struct in_addr
        {
        u_int32_t s_addr;   //IPv4地址,要用网络字节序表示
        }*/

        //分配地址信息,socket命名
        //2.int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));
        
        //创建一个监听队列
        //3.int listen(int sockfd, int backlog);
        listen(s_fd,10);
        //连接
        //4.int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
        int clen = sizeof(struct sockaddr_in);
        while(1){    //不断的读取和写入
                c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);    //连接
                if(c_fd == -1){
                        perror("accept");
                        exit(-1);    //连接失败退出
                }
                printf("get connect:%s\n",inet_ntoa(c_addr.sin_addr));
                        if(fork() == 0){    //创建子进程，实现同时运行两个while(1)
                                //6.write
                                while(1){
                                        memset(msg,0,sizeof(msg));    //清除原始数据
                                        printf("input: \n");
                                        gets(msg);    //没输入时阻塞
                                        write(c_fd,msg,strlen(msg));    //将输入信息存入msg进行交互
                                }
                        }
                        //5.read
                        while(1){
                                memset(readBuf,0,sizeof(readBuf));    //清楚原始数据
                                //ssize_t read(int fd, void *buf, size_t count);
                                n_read = read(c_fd,readBuf,128);    //读取
                                if(n_read == -1){
                                        perror("read");
                                }else{
                                        printf("get message:%d,from client:%s\n",n_read,readBuf);
                                }
                        }
                        //7.close
                        close(s_fd);
                        close(c_fd);
        }
        return 0;
}

TCP客户端

client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
int main(int argc,char **argv)
{
        int c_fd;
        int n_read;
        char readBuf[128];
        //char *msg = "msg from client!";
        char msg[128] = {0};
        struct sockaddr_in c_addr;

        if(argc != 3){
                printf("param is not good\n");
                exit(-1);
        }

        memset(&c_addr,0,sizeof(struct sockaddr_in));
        //1.int socket(int domain, int type, int protocol);

        c_fd = socket(AF_INET,SOCK_STREAM,0);
        if(c_fd == -1){
                perror("scoket");
                exit(-1);
        }

        c_addr.sin_family = AF_INET;
        c_addr.sin_port = htons(atoi(argv[2]));
        inet_aton(argv[1],&c_addr.sin_addr);

        /*struct sockaddr_in
                {
        sa_family_t sin_family;    //地址族:AF_INET
        u_int16_t sin_port;        //端口号,要使用网络字节序表示
        struct in_addr sin_addr;   //IPv4地址结构体
        char sin_zero[8];          //不使用
                }
        struct in_addr
        {
        u_int32_t s_addr;   //IPv4地址,要用网络字节序表示
        }*/
        //2. int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr)) == -1){
                perror("connect");
                exit(-1);
        }
        while(1){    //不断进行读写操作
                if(fork() == 0){    //创建子进程
                        //3.send
                        while(1){
                                memset(msg,0,sizeof(msg));
                                printf("input: \n");
                                gets(msg);
                                write(c_fd,msg,strlen(msg));
                        }
                }
                while(1){
                        //4.read
                        memset(readBuf,0,sizeof(readBuf));
                        n_read = read(c_fd,readBuf,128);
                        if(n_read == -1){
                                perror("read");
                        }else{
                                printf("get message from client : %d,%s\n",n_read,readBuf);
                        }
                }
        }
        //5.close
        close(c_fd);
        return 0;
}

多方消息收发 ，TCP服务端

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
int main(int argc,char **argv)
{
        int s_fd;
        int c_fd;
        int n_read;
        int mark = 0;
        char readBuf[128] = {0};
        //char *msg = "I get your connect!";
        char msg[128] = {0};
        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;

        if(argc != 3){
                printf("param is not good\n");
                exit(-1);
        }
        memset(&s_addr,0,sizeof(struct sockaddr_in));
        memset(&c_addr,0,sizeof(struct sockaddr_in));
        //1.int socket(int domain, int type, int protocol);

        s_fd = socket(AF_INET,SOCK_STREAM,0);
        if(s_fd == -1){
                perror("scoket");
                exit(-1);
        }

        s_addr.sin_family = AF_INET;
        s_addr.sin_port = htons(atoi(argv[2]));
        inet_aton(argv[1],&s_addr.sin_addr);

        /*struct sockaddr_in
                {
        sa_family_t sin_family;    //地址族:AF_INET
        u_int16_t sin_port;        //端口号,要使用网络字节序表示
        struct in_addr sin_addr;   //IPv4地址结构体
        char sin_zero[8];          //不使用
                }
        struct in_addr
        {
        u_int32_t s_addr;   //IPv4地址,要用网络字节序表示
        }*/


        //2.int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
        bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

        //3.int listen(int sockfd, int backlog);
        listen(s_fd,10);
        //4.int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
        int clen = sizeof(struct sockaddr_in);
        while(1){
                c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);
                if(c_fd == -1){
                        perror("accept");
                }
                mark++;
                printf("get connect:%s\n",inet_ntoa(c_addr.sin_addr));
                if(fork() == 0){
                        if(fork() == 0){
                                //6.write
                                while(1){
                                        sprintf(msg,"welcom No.%d client",mark);
                                        write(c_fd,msg,strlen(msg));
                                        sleep(3);
                                }
                        }
                        //5.read
                        while(1){
                                memset(readBuf,0,sizeof(readBuf));
                                n_read = read(c_fd,readBuf,128);
                                if(n_read == -1){
                                        perror("read");
                                }else{
                                        printf("get message:%d,from client:%s\n",n_read,readBuf);
                                }
                        }
                        //7.close
                        close(s_fd);
                        close(c_fd);
                        break;
                }
        }
        return 0;
}
Mr.多拉贡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
未知攻焉知防：从攻击者视角看网络安全的“攻守之道”
科技云报道
08-01 422
基于独特的“动态安全+AI”技术思想，瑞数信息综合运用自动化攻击保护、0day防护、多源低频防护、多维度分层分级对抗等多种安全防护策略和手段，还推出瑞数WAAP超融合平台，支持WAF、Bots防护、0day攻击防护、应用DDoS防护、API安全防护等多项安全产品单独或联合部署，能够覆盖Web、移动App、H5、API及IoT全应用渠道，提供多层级的联动防御机制，令企业在各类复杂的环境中，都可以轻松实现应用安全一体化防御。其次，由于供应链数量众多，类型错综复杂，导致安全难以做到统一管理，供应链风险与日俱增。
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 403
使用TCP协议支持与多个客户端同时通信。
【Vulnhub系列】Vulnhub Connect-The-Dots 靶场渗透（原创）
Lusen的博客
08-02 592
Vulnhub系列Connect-The-Dots靶场做题记录
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 698
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
堡垒机简单介绍
凡尘
08-05 470
堡垒机是一种用于控制和管理网络安全的重要工具，它在一个特定的网络环境下，为了保障网络和数据不受入侵和破坏，运用各种技术手段监控对网络内的服务器、网络设备、安全设备、数据库等设备的操作行为，以便于集中报警、及时处理及审计定责。登录功能：提供安全的远程访问接口。账号管理：实现对所有服务器、网络设备、安全设备等账号的集中管理。身份认证：对访问内部网络的用户进行身份验证。资源授权：基于用户、目标设备、时间、协议类型等要素实现细粒度的操作授权。访问控制。
接口测试学习笔记1
weixin_53666393的博客
08-03 905
同时也像白盒测试那样，检查程序的代码，但这种检查不像白盒测试那样详细、完整，一般只对程序模块之间的调用、核心代码进行检查，在集成测试时经常采用，一般也是程序员大量采用。现在企业说的接口测试，一般指的是Web接口测试或Http接口测试，主要指的是基于B/S架构的接口测试（B/S架构主要基于HTTP 超文本传输协议，所以也叫HTTP接口测试）对请求对象（网页、文件、图片...）进行的操作，就是一些命令，程序员在编程的时候使用，在接口文档中会指明，测试人员测试接口的时候，按照说明选择正确的方法。
自动获取ip地址什么意思？电脑ip地址怎么设置自动获取
hgdlip的博客
08-02 1097
在当今数字化时代，网络连接已成为我们日常生活和工作中不可或缺的一部分。然而，对于非技术用户而言，复杂的网络配置常常令人望而生畏。幸运的是，自动获取IP地址（Dynamic Host Configuration Protocol, DHCP）技术的出现，极大地简化了这一过程，让网络配置变得更加轻松和高效。下面跟着虎观代理小二一起来了解一下探讨自动获取IP地址含义，并详细介绍电脑怎样设置自动获取IP地址。
Modbus通讯协议
qq_3517289697的博客
08-02 741
Modbus协议是一种用于电子控制器之间的通信协议，‌它允许不同类型的设备之间进行通信，‌以便进行数据交换和控制。‌Modbus协议最初为可编程逻辑控制器（‌PLC）‌通信开发，‌现已广泛应用于工业自动化领域，‌包括但不限于工业控制、‌楼宇自动化、‌能源管理等领域。‌该协议支持多种通信接口和物理介质，‌包括串行（‌RS-232、‌RS-485等）‌、‌以太网以及无线通信等，‌使其能够适应各种不同的应用场景。‌。
Java实现抓包并将数据呈现到前端
LB_bei的博客
08-05 231
环境：windows10、jdk17、springboot3需求分析，首先需要对本地某个端口进行抓包，然后用websocket将数据传到前端。
Spark Steaming有状态转换实验
m0_59508634的博客
08-01 1216
打开一个新的shell窗口，切换到logfile目录下，创建一个log.txt文档保存，再创建一个log_new.txt文档保存，里面输入一些随意的单词，并用空格间隔开。注：log.txt输入为“a b c a b c d”，log_new.txt输入为“a b d e f a b e f”。在服务端输入以下字符串，并按回车，可以在客户端收到消息，并打印出来。在客户端输入字符串，并按回车，可以在服务端收到消息，并打印出来。的回滚来查看结果，因为回滚较快，所以在运行状态下查看结果截图较困难。
虚拟机能访问网页但ping不通百度
最新发布
weixin_45767431的博客
08-06 171
一些 VPN 网络配置会阻止 ICMP 流量，因为 ICMP 流量可以被用于网络探测和攻击，猜测是VPN干扰了ICMP。关闭VPN后，虚拟机能ping通百度。在主机上通过wireshark抓包，发现主机上能收到来自虚拟机的ICMP包，但没有收到返回包。能访问网页，说明DNS、TCP和HTTP没有问题，ping不通，说明ICMP应该出了问题。最近遇到了奇怪的问题，虚拟机能访问网页，但ping不通百度，记录一下问题的排查过程。首先通过traceroute追踪报文的转发过程，发现报文被转发给了默认网关。
探索全光网技术 | 全光网络技术方案选型建议三（医院场景）
正月十六工作室
08-05 824
同时，全光网络还支持冗余设计和备份路径，确保在网络出现故障时能够迅速恢复业务，保障医疗业务的连续性。而全光网络则具有长距离传输的优势，能够轻松覆盖医院的各个角落，包括手术室、病房、实验室等关键区域。老话说的好，网络3分建7分管。：汇聚层位于核心层和接入层之间，负责连接核心层和接入层的设备，实现网络流量的汇聚和分发。应采用高带宽、低时延的光纤传输介质，并结合高速交换技术和容错技术，确保数据的可靠传输。远程医疗协作：实现高清视频会议、远程手术指导等应用，要求网络具备极低的时延，以保障医生间的实时沟通和协作。
哪些系统需要按照等保2.0进行定级？
2301_79955948的博客
08-05 747
等保2.0（网络安全等级保护2.0）是中国政府制定的网络安全标准，旨在提高网络系统的安全防护能力，降低网络安全风险，保护国家安全、社会秩序和公民权益。等保2.0将网络系统分为五个安全保护等级，从第一级到第五级，每个级别对应不同的安全保护要求。
springboot开发的常用注解总结-配置组件类注解
lw的博客
08-03 782
为了写一个自定义@Conditional的demo，我们需要定义一个实现org.springframework.context.annotation.Condition接口的类，并在一个配置类中使用@Conditional注解来引用这个条件类。下面是一个简单的示例，其中我们将基于一个系统属性来决定是否创建某个Bean。// 检查系统属性或环境变量中是否存在该属性，并且其值为true String property = env . getProperty(PROPERTY_NAME);
拓扑未来物联网平台简介
gavinpeng的专栏
08-01 512
拓扑未来物联网平台是基于Thingsboard二次开发的PaaS平台，支持适配各种网络环境和协议类型，可实现各种传感器和智能硬件的快速接入。
日志远程同步实验
ANCHG_的博客
08-03 289
日志远程同步实验
zero - hackmyvm
tanbinn的博客
08-02 251
hackmyvm的zero靶场
网络基础之(2)初级网络知识
Once_day的回忆
08-03 418
网络协议是为计算机网络中进行数据交换而建立的规则、标准或约定的集合。语义：解释控制信息每个部分的意义，规定了需要发出何种控制信息，以及完成的动作与做出什么样的响应。语法：用户数据与控制信息的结构与格式，以及数据出现的顺序。时序：事件发生顺序的详细说明。为什么需要对协议分层？降低单个协议复杂程度，利于实现层间独立，易于标准化保持协议栈的灵活性。层间关系？每一层都使用了下一层提供的服务，每一层都为上一层提供服务。
LangChain与WebSocket：实时通信的新纪元
2401_85763803的博客
08-06 417
LangChain，作为一个假设的编程辅助工具，如果存在，它可能会支持WebSocket通信，以增强其在实时应用场景中的功能。尽管LangChain是一个假设的工具，但通过本文的探讨，我们可以看到WebSocket通信对于编程辅助工具的巨大潜力。本文通过详细的解释和伪代码示例，展示了LangChain在WebSocket通信方面的潜在应用。随着实时通信技术的发展，我们期待看到更多支持WebSocket的编程辅助工具的出现。这包括定义处理接收到的消息的函数、处理错误的函数，以及启动WebSocket服务。
Linux系统编程入门指南_v2.0
"Linux系统编程_v2.0" Linux系统编程是一个深入理解操作系统内核与应用程序交互的领域，主要涉及在Linux环境下开发系统级程序。这个资料可能是由北京迅为电子有限公司提供的一个教程，版本号为V2.0，旨在帮助初学者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值