[计算机网络]---网络编程套接字

news2024/11/28 6:39:27

前言

作者：小蜗牛向前冲

名言：我可以接受失败，但我不能接受放弃

  如果觉的博主的文章还不错的话，还请点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正 

目录

 一、基础知识

1、源IP地址和目的IP地址

 2、端口号

二、网络套接字

1、网络字节序

2、socket编程接口 

三、基于tcp协议的网络通信 

1、服务器的编写 

 2、客户端的编写

3、日志报告的编写 

 四、TCP协议通讯流程

1、通信流程

2、三次握手和四次挥手 

本期学习：网络基础知识，网络套接字，基于tcp协议的网络编程,tcp协议的三次握手和四次挥手。

 一、基础知识

1、源IP地址和目的IP地址

源IP地址：

  • 源IP地址是指发起网络通信的设备或主机的IP地址。
  • 在TCP/IP协议中，源IP地址用于标识数据包的来源，使得接收方知道从哪里收到数据。
  • 源IP地址包含在网络数据包的IP头部中。

目的IP地址：

  • 目的IP地址是指网络通信的目标设备或主机的IP地址。
  • 在TCP/IP协议中，目的IP地址用于指定数据包的目标，确保数据包被传递到正确的位置。
  • 目的IP地址同样包含在网络数据包的IP头部中。

下面我们用唐僧取经的例子来理解：

唐僧到女儿国，那国王问，高僧从那来，到哪里去 ，在网络中就是问源ip和目的ip。

也可能会问高僧上一站从那来，下一站到哪里去。在网络中指的就是MAC地址。

MAC地址：

MAC地址（Media Access Control address），也称为物理地址或硬件地址，是网络通讯中用于唯一标识网络接口控制器（NIC，网络接口卡）的一个地址。每个网络设备的NIC都有一个全球唯一的MAC地址，这个地址在生产时被固化在硬件中。

MAC地址的长度通常是48位（6个字节），有时也表示为64位以适应某些特定技术标准。

 MAC地址通常以十六进制数表示，每个字节之间用冒号（:）或者破折号（-）分隔，例如00:1A:2B:3C:4D:5E或00-1A-2B-3C-4D-5E。

 2、端口号

      我们光有IP地址就可以完成通信了嘛? 想象一下发qq消息的例子, 有了IP地址能够把消息发送到对方的机器上, 但是还需要有一个其他的标识来区分出, 这个数据要给哪个程序进行解析。所以就提出用端口号来标识唯一的程序(服务器)。

端口号(port)是传输层协议的内容:

  • 端口号是一个2字节16位的整数;
  • 端口号用来标识一个进程, 告诉操作系统, 当前的这个数据要交给哪一个进程来处理;
  • IP地址 + 端口号能够标识网络上的某一台主机的某一个进程;
  • 一个端口号只能被一个进程占用

问题1： 我们之前在学习系统编程的时候, 学习了 pid 表示唯一一个进程; 此处我们的端口号也是唯一表示一个进程. 那么这 两者之间是怎样的关系?

a:系统是系统，网络是网络，这里可以达到解耦的效果

b: 需要客户端每次都能找到服务端，而pid是在进程每次生成时随机分配的

c:不是所以的网络进程都需要网络提供网络服务或者请求，但是所以的进程都需要用pid进行标识

所以说：一个进程可以绑定多个端口号; 但是一个端口号不能被多个进程绑定

注意：

  • 端口号范围从0到65535，其中0到1023是被知名服务占用的端口号，称为“系统端口”或“保留端口”，而1024到65535是动态或私有端口，用于一般应用程序或自定义服务(下面我们进行的测试常用8080端口)
  • 传输层协议(TCP和UDP)的数据段中有两个端口号, 分别叫做源端口号和目的端口号. 就是在描述 "数据是谁发的, 要 发给谁"。

二、网络套接字

1、网络字节序

我们已经知道,内存中的多字节数据相对于内存地址有大端和小端之分, 磁盘文件中的多字节数据相对于文件中的偏 移地址也有大端小端之分, 网络数据流同样有大端小端之分. 那么如何定义网络数据流的地址呢? 

在网络中无论是发送主机还是接收主机都是将：缓冲区中的数据按内存地址从低到高的顺序发送或者接收

因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址

TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节

也就是说不管这台主机是大端机还是小端机，到会按照大端机发送。

库函数做网络 字节序和主机字节序的转换。 

#include<arpa/inet.h>

uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
  •  这些函数名很好记,h表示host,n表示network,l表示32位长整数,s表示16位短整数。
  • 例如htonl表示将32位的长整数从主机字节序转换为网络字节序,例如将IP地址转换后准备发送。
  • 如果主机是小端字节序,这些函数将参数做相应的大小端转换然后返回; 如果主机是大端字节序,这些函数不做转换,将参数原封不动地返回.

2、socket编程接口 

API（Application Programming Interface）是一组定义在软件中不同组件之间交互的规范和工具。API可以看作是一座桥梁，它定义了如何访问或使用软件组件的方法。在软件开发中，API允许不同的程序部分之间进行通信，以便它们能够相互协作而无需详细了解彼此的内部实现。

常见的API 

// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);
// 绑定端口号 (TCP/UDP, 服务器) 
int bind(int socket, const struct sockaddr *address,
 socklen_t address_len);
// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);
// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,
 socklen_t* address_len);
// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr,
 socklen_t addrlen);

sockaddr结构

 sockaddr 结构（有时候在不同的系统中会有稍微不同的变体，如 sockaddr_in）是用于表示套接字地址信息的数据结构，在网络编程中经常会遇到。它通常用于指定网络通信中的端点地址，包括 IP 地址和端口号。

struct sockaddr {
    unsigned short sa_family;    // 地址族，如 AF_INET（IPv4）或 AF_INET6（IPv6）
    char sa_data[14];            // 地址数据
};

主要的字段：

  1. sa_family：用于指定地址族，表示地址的类型。例如，AF_INET 表示 IPv4 地址族，AF_INET6 表示 IPv6 地址族等。这个字段是一个无符号短整型（unsigned short）。

  2. sa_data：包含地址的具体数据，通常用于存储 IP 地址和端口号等信息。在不同的地址族下，这个字段的内容会有所不同。

在实际使用中，为了更方便地表示 IPv4 地址，通常会使用更具体的套接字地址结构，如 sockaddr_in，它的定义如下： 

struct sockaddr_in {
    short int sin_family;          // 地址族，如 AF_INET
    unsigned short int sin_port;   // 端口号
    struct in_addr sin_addr;       // IPv4 地址
    unsigned char sin_zero[8];     // 未使用的填充字段
};

三、基于tcp协议的网络通信 

上面我们说了怎么多，下面我们就用起来，虽然我们现在还是那么清楚udp和tcp协议，但是我大概清楚了他是用来通信的。

这里我们要实现一个简单版本的服务器为客户端提供服务，这里我们的服务仅仅需要回显信息。

我们要写一个服务器

tcpServer.hpp
tcpServer.cc

一个客户端

tcpClient.hpp
tcpClinet.cc

一个日志报告

log.hpp

1、服务器的编写 

tcpServer.hpp:这里我们要完成服务器的初始化，启动和销毁。

服务器的初始化是通过socket创建套嵌字，bind绑定网络，在进行listen监听.

启动要完成accept获取新链接,在执行程序任务。

这里我们在执行任务的过程中，我们可以：

  • 让程序自己执行
  • 创建子进程执行
  • 让多线程执行
  • 让线程池执行

这里为了让程序更好的理解，我们就让子进程执行我们serverio。 

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#include <pthread.h>

#include "log.hpp"
#include "Task.hpp"
#include "ThreadPool.hpp"

namespace server
{
    enum
    {
        USAGE_ERR = 1, // usage_err
        SOCKET_ERR,    // sockft_err
        BIND_ERR,      // bind_err
        LISTEN_ERR     // listen_err
    };

    static const uint16_t gport = 8080;
    static const int gbacklog = 5;
    class TcpServer; // 这是一个前置声明，我们在类tcpServer中定义了ThreadData数据的类防止出现循环依赖

    class ThreadData
    {
    public:
        ThreadData(TcpServer *self, int sock) : _self(self), _sock(sock)
        {
        }

    public:
        TcpServer *_self;
        int _sock;
    };
    class TcpServer
    {
    public:
        TcpServer(const uint16_t &port = gport) : _listensock(-1), _port(port)
        {
        }

        void initServer()
        {
            // 1 创建套接字
            _listensock = socket(AF_INET, SOCK_STREAM, 0); // sock_stream
            if (_listensock < 0)
            {
                logMessage(FATAL, "create error socket");
                exit(SOCKET_ERR);
            }
            logMessage(NORMAL, "create socket success:%d", _listensock);

            // 2 bind自己的网络信息
            struct sockaddr_in local;
            memset(&local, 0, sizeof(local));
            local.sin_family = AF_INET;
            local.sin_port = htons(_port);
            local.sin_addr.s_addr = INADDR_ANY; // inaddr_any

            if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
            {
                logMessage(FATAL, "bind error ");
                exit(BIND_ERR);
            }
            logMessage(NORMAL, "bind socket success");

            // 3 设置socket 为监听状态
            if (listen(_listensock, gbacklog) < 0)
            {
                logMessage(FATAL, "listen socket success");
                exit(LISTEN_ERR);
            }
            logMessage(NORMAL, "listen socket success");
        }

        void start()
        {
            for (;;)
            {
                // 4 server获取链接
                //  sock, 和client进行通信的fd
                struct sockaddr_in peer;
                socklen_t len = sizeof(peer);
                int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
                if (sock < 0)
                {
                    logMessage(ERROR, "accept error, next");
                    continue;
                }
                logMessage(NORMAL, "accept a new link success, get new sock: %d", sock);

                // 5. 这里就是一个sock，未来通信我们就用这个sock，面向字节流的，后续全部都是文件操作！
                // version1
                // serviceIO(sock);
                // close(sock);
                // version2多进程版本
                pid_t id = fork();
                // 我们让子进程执行的io任务，父进程什么都不做，回收子进程就好
                if (id == 0)
                {
                    close(_listensock);
                    serviceIO(sock);
                    close(sock);
                    exit(0);
                }
                close(sock);

                // 父进程
                pid_t ret = waitpid(id, nullptr, 0);
                if (ret > 0)
                {
                    std::cout << "waitsuccess: " << ret << std::endl;
                }
                // version3多线程
                // pthread_t tid;
                // ThreadData *td = new ThreadData(this, sock);
                // pthread_create(&tid, nullptr, threadRoutine, td);
                // pthread_join(tid, nullptr);
                // version4 线程池
                // ThreadPool<Task>::getInstance()->push(Task(sock, serviceIO));
            }
        }
        // static void *threadRoutine(void *args)
        // {
        //     pthread_detach(pthread_self());
        //     ThreadData *td = static_cast<ThreadData *>(args);
        //     serviceIO(td->_sock);
        //     close(td->_sock);
        //     delete td;
        //     return nullptr;
        // }
        ~TcpServer()
        {
        }

    private:
        int _listensock; // 用了监听
        uint16_t _port;
    };
}

下面是一些任务：

#pragma once

#include <iostream>
#include <string>
#include <cstdio>
#include <functional>

using namespace std;

void serviceIO(int sock)
{
    char buffer[1024];
    while (true)
    {
        ssize_t n = read(sock, buffer, sizeof(buffer) - 1);
        if (n > 0)
        {
            // 把读到的数据当做字符串
            buffer[n] = 0;
            cout << "recv message" << buffer << endl;

            // 信息返回
            string outbuffer = buffer;
            outbuffer += buffer;
            outbuffer += "server[echo]";
            // outbuffer.c_str(),将字符串类型的指针，转换为字符类型的指针
            write(sock, outbuffer.c_str(), sizeof(outbuffer) - 1);
        }
        else if (n == 0)
        {
            // client退出
            logMessage(NORMAL, "client quit,me to");
            break;
        }
    }
}

class Task
{
    // using 用于创建类型别名
    using func_t = function<void(int)>;

public:
    Task()
    {
    }
    Task(int sock, func_t func)
        : _sock(sock), _callback(func)
    {
    }
    void operator()()
    {
        _callback(_sock);
    }
    ~Task()
    {
    }

private:
    int _sock;
    func_t _callback;
};

tcpServer.cc:主程序的执行

#include "tcpserver.hpp"
#include "daemon.hpp"
#include <memory>

using namespace server;
using namespace std;

static void Usage(string proc)
{
    cout << "\nUsage:\n\t" << proc << " local_port\n\n";
}

// tcp服务器，启动上和udp server一模一样
// ./tcpserver local_port
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port = atoi(argv[1]);

    unique_ptr<TcpServer> tsvr(new TcpServer(port));
    tsvr->initServer();

    // daemonSelf();
    tsvr->start();
    // daemonSelf();

    return 0;
}

 2、客户端的编写

tcpclient.hpp:对于客户端的初始化，我们仅仅只是需要创建套接字，而bind操作系统会帮助我们完成。

客户端的启动我们要用connect接收链接

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

#define NUM 1024
using namespace std;
class tcpclient
{
public:
    tcpclient(const string &serverip, const uint16_t &serverport)
        : _sock(-1), _serverip(serverip), _serverport(serverport)
    {
    }
    void initclient()
    {
        // 1 创建套接字
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_sock < 0)
        {
            std::cerr << "socket create error" << std::endl;
            exit(2);
        }
    }
    void start()
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(_serverport);
        server.sin_addr.s_addr = inet_addr(_serverip.c_str());

        if (connect(_sock, (struct sockaddr *)&server, sizeof(server)) != 0)
        {
            std::cerr << "socket connect error" << std::endl;
        }
        else
        {
            string msg;
            while (true)
            {
                cout << "Enter#";
                std::getline(std::cin, msg);
                write(_sock, msg.c_str(), sizeof(msg));

                char buffer[NUM];
                int n = read(_sock, buffer, sizeof(buffer));
                if (n > 0)
                {
                    // 目前我们把读到的数据当成字符串, 截止目前
                    buffer[n] = 0;
                    std::cout << "Server回显# " << buffer << std::endl;
                }
                else
                    break;
            }
        }
    }

    ~tcpclient()
    {
        if (_sock >= 0)
            close(_sock);
    }

private:
    int _sock;
    std::string _serverip;
    uint16_t _serverport;
};

tcpcline.cc:执行程序 

#include "tcpclient.hpp"
#include <memory>

using namespace std;

static void Usage(string proc)
{
    cout << "\nUsage:\n\t" << proc << " serverip serverport\n\n";
}
// ./tcpclient serverip serverport
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    unique_ptr<tcpclient> tcli(new tcpclient(serverip, serverport));
    tcli->initclient();
    tcli->start();
    return 0;
}

3、日志报告的编写 

对于日志报告我们通过对错误进行分类，进行不同等级的日志错误信息输入。

#pragma once

#include <iostream>
#include <cstdio>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>

// 定义错误类型
#define DEBUG 0   // debug
#define NORMAL 1  // normal
#define WARNING 2 // warning
#define ERROR 3   // error
#define FATAL 4   // fatal致命

#define NUM 1024

// 定于不同类型日常写入的文件
#define LOG_NORMAL "log.txt"
#define LOG_ERR "log.error"
// 标志位
const char *to_levelstr(int level)
{
    switch (level)
    {
    case DEBUG:
        return "DEBUG";
    case NORMAL:
        return "NORMAL";
    case WARNING:
        return "NORMAL";
    case ERROR:
        return "ERROR";
    case FATAL:
        return "FATAL";
    }
}

// 日志信息
void logMessage(int level, const char *format, ...) // 可变参数函数
{
    // [日志等级] [时间戳/时间] [pid] [messge]
    // [WARNING] [2023-05-11 18:09:08] [123] [创建socket失败]
    char logprefix[NUM]; // 存放日志前缀
    snprintf(logprefix, sizeof(logprefix), "[%d][%ld][pid::%d]",
             to_levelstr(level), (long int)time(nullptr), getpid());

    char logcontent[NUM];
    va_list arg;
    snprintf(logprefix, sizeof(logprefix), format, arg);
    FILE *log = fopen(LOG_NORMAL, "a"); // log_normal
    FILE *err = fopen(LOG_ERR, "a");    // log_error

    if (log != nullptr && err != nullptr)
    {
        FILE *curr = nullptr;
        if (level == DEBUG || level == NORMAL || level == WARNING)
            curr = log;
        if (level == ERROR || level == FATAL)
            curr = err;
        if (curr)
            fprintf(curr, "%s%s\n", logprefix, logcontent);

        fclose(log);
        fclose(err);
    }
}

程序运行测试：

 

 四、TCP协议通讯流程

1、通信流程

TCP协议的通讯流程可以分为以下几个步骤：

  1. 创建连接：客户端和服务端都需要创建一个套接字（socket），这通常涉及到系统调用如`socket()`。

  2. 连接请求：客户端向服务端的套接字发送连接请求报文，这一步可以通过`connect()`函数来实现。

  3. 服务器响应：服务器收到客户端的连接请求后，需要进行确认，以确定是否允许连接。这通常涉及三部分握手：

    • 服务器的确认ACK
    • 客户端的确认SYN
    • 服务器的应答ACK

  4. 连接建立：在双方完成了三次握手后，连接正式建立。此时，客户端可以开始发送数据给服务器，而服务器也可以开始接收数据。

  5. 数据传输：在这个阶段，客户端和服务器端可以进行数据的读写操作。这些操作包括读取（`recv()`）、写入（`send()`）以及关闭连接（`close()`）。

  6. 断开连接：当通信结束后，客户端或服务器端可以选择断开当前的连接。这通常涉及到四次挥手：

    • 服务器的释放FIN
    • 客户端的确认ACK
    • 服务器的确认ACK
    • 客户端的释放ACK

  7. 错误处理：在通信过程中，可能会遇到各种错误，如数据包丢失或乱序。TCP提供了自动重传机制来处理这些问题。

2、三次握手和四次挥手 

TCP三次握手（Three-way Handshake）:

  1. 客户端发送连接请求（SYN）： 客户端向服务器发送一个特殊的TCP报文段，该报文段中设置了SYN（同步）标志位，表明客户端要求建立连接，并指明初始序列号（ISN）。

  2. 服务器确认请求并发送自己的连接请求（SYN + ACK）： 服务器接收到客户端的连接请求后，向客户端发送一个确认报文段。该报文段中既包含了确认序号（ACK），也设置了SYN标志位，表示服务器同意建立连接，并指明自己的初始序列号。

  3. 客户端确认服务器的连接请求（ACK）： 客户端接收到服务器的确认报文后，会再次向服务器发送一个确认报文段，其中确认号字段会加1，表示客户端也同意建立连接。

 TCP四次挥手（Four-way Handshake）

  1. 发起关闭请求： 通信的一方（称为主动关闭方）发送一个FIN报文段，表示它已经完成了数据的发送任务。

  2. 接收关闭请求并发送确认： 接收到关闭请求的一方（被动关闭方）收到FIN报文后，会发送一个确认报文，表明它已经接收到关闭请求。

  3. 发送数据并发起关闭请求： 被动关闭方发送完所有数据后，也会向主动关闭方发送一个FIN报文段，表示它已经完成了数据的发送任务，并且准备关闭连接。

  4. 确认关闭请求并发送关闭确认： 主动关闭方接收到被动关闭方的FIN报文后，会发送一个确认报文，表明它已经接收到了关闭请求。一旦被动关闭方收到了这个确认，连接就会关闭。

在linux下有许多命令，老是忘记，在下面的文章中多会为大家分享一些小命令： 

Linux小命令 :

netstat 是一个用于显示网络状态信息的命令行工具，常用于查看网络连接、路由表、接口统计等信息。在给定的命令中，-nltp 参数的含义如下：

  • -n: 显示数字形式的地址和端口号，而不进行域名和服务名称的解析。
  • -l: 仅显示监听状态的连接。
  • -t: 仅显示TCP协议的连接。
  • -p: 显示与连接相关的进程标识符（PID）及进程名称。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1448391.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Web基础01-HTML+CSS

Web基础01-HTML+CSS

目录 一、HTML 1.概述 2.html结构解析 3.HTML标签分类 4.HTML标签关系 5.HTML空元素 6.HTML属性 7.常用标签 &#xff08;1&#xff09;HTML标签 &#xff08;2&#xff09;标题标签 &#xff08;3&#xff09;换/折行标签 &#xff08;4&#xff09;段落标签 &am…
阅读更多...
Qt之条件变量QWaitCondition详解

Qt之条件变量QWaitCondition详解

QWaitCondition内部实现结构图&#xff1a; 相关系列文章 C之Pimpl惯用法 目录 1.简介 2.示例 2.1.全局配置 2.2.生产者Producer 2.3.消费者Consumer 2.4.测试例子 3.原理分析 3.1.辅助函数CreateEvent 3.2.辅助函数WaitForSingleObject 3.3.QWaitConditionEvent …
阅读更多...
java客运管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

java客运管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

一、源码特点 java客运管理系统是一套完善的java web信息管理系统&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。开发环境为TOMCAT7.0,Myeclipse8.5开发&#xff0c;数据库为Mysql5.0&#…
阅读更多...
国产制造，欧美品质：爱可声助听器产品质量获国际认可

国产制造，欧美品质：爱可声助听器产品质量获国际认可

随着科技的发展和全球化的推进&#xff0c;越来越多的中国制造产品开始走向世界舞台。其中&#xff0c;爱可声助听器凭借其卓越的产品质量&#xff0c;成为了国产制造的骄傲。 国产制造指的是在中国境内生产的产品&#xff0c;欧美品质则是指产品在设计、生产、质量控制等方面…
阅读更多...
不止于浏览器：掌握Node.js，开启全栈开发新篇章！

不止于浏览器：掌握Node.js，开启全栈开发新篇章！

介绍&#xff1a;Node.js是一个基于Chrome V8引擎的JavaScript运行时环境&#xff0c;特别适合构建高性能的网络服务器和实时应用。具体介绍如下&#xff1a; 服务器端JavaScript&#xff1a;Node.js的核心优势之一是在服务器端运行JavaScript&#xff0c;这使得前端开发者可以…
阅读更多...
KAJIMA CORPORATION CONTEST 2024（AtCoder Beginner Contest 340）ABCDEF 视频讲解

KAJIMA CORPORATION CONTEST 2024（AtCoder Beginner Contest 340）ABCDEF 视频讲解

这场比较郁闷&#xff0c;C题短路&#xff0c;连续4次WA&#xff0c;导致罚时太多 A - Arithmetic Progression Problem Statement Print an arithmetic sequence with first term A A A, last term B B B, and common difference D D D. You are only given inputs for w…
阅读更多...
【论文模型讲解】CLIP（Learning Transferable Visual Models From Natural Language Supervision）

【论文模型讲解】CLIP（Learning Transferable Visual Models From Natural Language Supervision）

文章目录 前言0 摘要1 Introduction and Motivating Work2 Approach2.0 模型整体结构2.1 数据集2.2 选择一种高效的预训练方法2.3 模型选择与缩放2.4 训练 3 实验3.1 zero-shot 迁移3.1.1 与 Visual N-grams 对比3.1.2 Prompt Engineering and Ensembling3.1.3 zero-shot CLIP …
阅读更多...
【数据结构】哈希桶封装出map和set

【数据结构】哈希桶封装出map和set

利用之前的哈希桶封装出unordered_map和unordered_set。 这个封装并不简单&#xff0c;迭代器的使用&#xff0c;模板参数的繁多&#xff0c;需要我们一层一层封装。 map是一个k - v类型&#xff0c;set是k类型&#xff0c;那么就明确了如果需要封装&#xff0c;底层的tables…
阅读更多...
产品经理面试题解析：业务架构是通往成功的关键吗？

产品经理面试题解析：业务架构是通往成功的关键吗？

大家好&#xff0c;我是小米&#xff01;今天我要和大家聊的是产品经理面试中的一个热门话题&#xff1a;“业务架构”&#xff01;相信不少小伙伴在准备面试的时候都会遇到这个问题&#xff0c;究竟什么是业务架构&#xff1f;它又与产品经理的工作有着怎样的关系呢&#xff1…
阅读更多...
统计图饼图绘制方法（C语言）

统计图饼图绘制方法（C语言）

统计图饼图绘制方法&#xff08;C语言&#xff09; 常用的统计图有条形图、柱形图、折线图、曲线图、饼图、环形图、扇形图。 前几类图比较容易绘制&#xff0c;饼图绘制较难。今值此介绍饼图的绘制方法。 本方法采用C语言的最基本功能&#xff1a; &#xff08; 1.&#xff09…
阅读更多...
【AI视野·今日NLP 自然语言处理论文速览 第七十九期】Thu, 18 Jan 2024

【AI视野·今日NLP 自然语言处理论文速览 第七十九期】Thu, 18 Jan 2024

AI视野今日CS.NLP 自然语言处理论文速览 Thu, 18 Jan 2024 Totally 35 papers &#x1f449;上期速览✈更多精彩请移步主页 Daily Computation and Language Papers Deciphering Textual Authenticity: A Generalized Strategy through the Lens of Large Language Semantics …
阅读更多...
vue3+ts+vite+uniapp项目常见问题

vue3+ts+vite+uniapp项目常见问题

vue3tsvite中""路径失效的问题 ""需要进行配置&#xff1a; 首先npm install types/node --save-dev&#xff08;需要用到node其中的path&#xff09;接着在vite.config.ts配置文件中进行配置&#xff1a; 引入 import path from ‘path’&#xff0c;然…
阅读更多...
进阶C语言-动态内存管理

进阶C语言-动态内存管理

动态内存管理 &#x1f388;1.为什么存在动态内存分配&#x1f388;2.动态内存函数的介绍&#x1f52d;2.1malloc和free函数&#x1f52d;2.2calloc函数&#x1f52d;2.3realloc函数 &#x1f388;3.常见的动态内存错误&#x1f52d;3.1对NULL指针的解引用操作&#x1f52d;3.2…
阅读更多...
2024.2.9

2024.2.9

作业1 请使用递归实现n&#xff01; #include<stdio.h> #include<string.h> #include<stdlib.h>int fun(int m) {if(m0)return 1;else{return m*fun(m-1);} } int main(int argc, const char *argv[]) {int m;printf("please enter m:");scanf(&…
阅读更多...
TCP高频知识点

TCP高频知识点

本篇文章主要讲述一下在面试过程中TCP的高频知识点 1.TCP三次握手流程图: 客户端发送一个SYN&#xff08;同步&#xff09;报文段给服务器&#xff0c;选择一个初始序列号&#xff0c;并设置SYN标志位为1。服务器接收到客户端的SYN报文段后&#xff0c;回复一个ACK&#xff08…
阅读更多...
Linux_进程概念

Linux_进程概念

硬件系统 软件系统 进程概念 进程状态 孤儿进程 进程优先级 一.硬件系统 1.1 冯诺依曼体系结构 数学家冯诺依曼提出了计算机制造的三个基本原则&#xff0c;即采用二进制逻辑、程序存储执行以及计算机由五个部分组成&#xff08;运算器、控制器、存储器、输入设备、输出设备&a…
阅读更多...
MATLAB实现朴素贝叶斯分类

MATLAB实现朴素贝叶斯分类

朴素贝叶斯（Naive Bayes）是一种基于贝叶斯定理的分类算法，它假设特征之间相互独立，从而简化了计算复杂性。该算法常用于文本分类、垃圾邮件过滤、情感分析等应用场景。 MATLAB实现鸢尾花数据集分类代码如下： clear load fisheriris X = meas(:,1:2); Y = species; labels…
阅读更多...
勒索病毒最新变种.target勒索病毒来袭，如何恢复受感染的数据？

勒索病毒最新变种.target勒索病毒来袭，如何恢复受感染的数据？

导言&#xff1a; 在当今数字化时代&#xff0c;数据被视为企业和个人最重要的资产之一。然而&#xff0c;随着技术的进步&#xff0c;网络安全威胁也在不断演变。其中&#xff0c;勒索病毒是一种极具破坏性的威胁&#xff0c;而".target"勒索病毒是近期备受关注的一…
阅读更多...
【AI视野·今日CV 计算机视觉论文速览 第293期】Fri, 19 Jan 2024

【AI视野·今日CV 计算机视觉论文速览 第293期】Fri, 19 Jan 2024

AI视野今日CS.CV 计算机视觉论文速览 Fri, 19 Jan 2024 Totally 103 papers &#x1f449;上期速览✈更多精彩请移步主页 Daily Computer Vision Papers ParaHome: Parameterizing Everyday Home Activities Towards 3D Generative Modeling of Human-Object Interactions Aut…
阅读更多...
NSSCTF Round#18 RE GenshinWishSimulator WP

NSSCTF Round#18 RE GenshinWishSimulator WP

恶搞原神抽卡模拟器 看到软件的界面&#xff0c;大致有三种思路&#xff1a; 修改石头数量一直抽&#xff0c;如果概率正常肯定能抽到&#xff08;但是估计设置的概率是0&#xff09;在源码里找flag的数据把抽卡概率改成100%直接抽出来 Unity逆向&#xff0c;根据经验应该dnsp…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023