使用c/c++和UDP协议写一个图像传输库，不会丢包的

要实现不丢包的图像传输，可以考虑使用可靠传输协议，如TCP。但是，对于实时性要求较高的图像传输场景，UDP协议是更好的选择。

以下是使用c/c++和UDP协议实现不丢包的图像传输库的一般步骤：

1. 将要传输的图像分割成固定大小的数据包，并添加序列号和校验和。
2. 发送数据包时，设置接收方的接收窗口大小，并等待接收方的ACK确认。
3. 接收方接收到数据包后，检查序列号和校验和是否正确，如果正确，则发送ACK确认。
4. 发送方在接收到ACK确认后，将发送窗口向前移动，并继续发送下一个数据包。
5. 如果发送方在一定时间内未收到ACK确认，则重传该数据包。

以下是一个简单的示例代码：

发送方：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#define FRAME_SIZE 1024 //数据包大小
#define TIMEOUT 5000 //超时时间（ms）

struct frame_t {
    int seq_num; //序列号
    int checksum; //校验和
    char data[FRAME_SIZE]; //数据
};

int main(int argc, char *argv[]) {
    int sockfd;
    struct sockaddr_in servaddr;
    socklen_t servlen = sizeof(servaddr);
    int seq_num = 0;
    int expected_seq_num = 0;
    struct timeval tv;
    fd_set readfds;
    char *filename = argv[1];

    FILE *fp = fopen(filename, "rb");
    if (fp == NULL) {
        perror("fopen");
        exit(1);
    }

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        perror("socket");
        exit(1);
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(12345);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    while (1) {
        struct frame_t frame;
        int n = fread(frame.data, 1, FRAME_SIZE, fp);
        if (n <= 0) {
            break;
        }
        frame.seq_num = seq_num++;
        frame.checksum = 0;
        for (int i = 0; i < n; i++) {
            frame.checksum += frame.data[i];
        }
        sendto(sockfd, &frame, sizeof(frame), 0, (struct sockaddr *)&servaddr, servlen);
        printf("send seq_num=%d\n", frame.seq_num);

        FD_ZERO(&readfds);
        FD_SET(sockfd, &readfds);
        tv.tv_sec = TIMEOUT / 1000;
        tv.tv_usec = (TIMEOUT % 1000) * 1000;
        int retval = select(sockfd + 1, &readfds, NULL, NULL, &tv);
        if (retval < 0) {
            perror("select");
            exit(1);
        } else if (retval == 0) {
            printf("timeout\n");
            continue;
        } else {
            struct frame_t ack;
            recvfrom(sockfd, &ack, sizeof(ack), 0, (struct sockaddr *)&servaddr, &servlen);
            printf("recv ack_seq_num=%d\n", ack.seq_num);
            if (ack.seq_num == expected_seq_num) {
                expected_seq_num++;
            }
        }
    }

    fclose(fp);
    close(sockfd);
    return 0;
}

接收方：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#define FRAME_SIZE 1024 //数据包大小

struct frame_t {
    int seq_num; //序列号
    int checksum; //校验和
    char data[FRAME_SIZE]; //数据
};

int main(int argc, char *argv[]) {
    int sockfd;
    struct sockaddr_in servaddr;
    socklen_t servlen = sizeof(servaddr);
    int expected_seq_num = 0;

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        perror("socket");
        exit(1);
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(12345);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(sockfd, (struct sockaddr *)&servaddr, servlen) < 0) {
        perror("bind");
        exit(1);
    }

    while (1) {
        struct frame_t frame;
        recvfrom(sockfd, &frame, sizeof(frame), 0, (struct sockaddr *)&servaddr, &servlen);
        printf("recv seq_num=%d\n", frame.seq_num);
        int checksum = 0;
        for (int i = 0; i < FRAME_SIZE; i++) {
            checksum += frame.data[i];
        }
        if (frame.seq_num == expected_seq_num && frame.checksum == checksum) {
            struct frame_t ack;
            ack.seq_num = expected_seq_num++;
            sendto(sockfd, &ack, sizeof(ack), 0, (struct sockaddr *)&servaddr, servlen);
            printf("send ack_seq_num=%d\n", ack.seq_num);
        }
    }

    close(sockfd);
    return 0;
}

需要注意的是，上述代码中没有考虑网络延迟和丢包的情况，实际应用中需要进行更加完善的处理。