C语言 如何使用结构体数组的成员作为fread()的第一个参数？

sdnqo3pr  于 2023-10-16  发布在  其他
关注(0)|答案(2)|浏览(103)

我得到
传递“fread”的参数1使指针从整数变为不带强制转换的整数
当我做

  1. fread((*pArr)[i][j]->b, sizeof(unsigned char), 1, file);

在我的readPixelsBMP函数中。和

  1. fread(&(*pArr)[i][j]->b, sizeof(unsigned char), 1, file);

使其崩溃但不发出警告。我的程序只是一个程序，它应该读取一个图像并写入同一个图像。下面是我的全部代码：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.     
  4. struct BMP_Header {
  5.     char signature[2];
  6.     int size;
  7.     short reserved1;
  8.     short reserved2;
  9.     int offset_pixel_array;
  10. };
  11.     
  12. struct DIB_Header{
  13.     int  size;
  14.     int width;
  15.     int height;
  16.     short planes;
  17.     short bits_per_pixel;
  18.     int compression;
  19.     int image_size;
  20.     int x_per_meter;
  21.     int y_per_meter;
  22.     int colors_in_table;
  23.     int important_colors;
  24. };
  25.     
  26. struct Pixel{
  27.     unsigned char r;
  28.     unsigned char b;
  29.     unsigned char g;
  30. };
  31. void readBMPHeader(FILE* file, struct BMP_Header* header) {
  32.     fread(&header->signature, sizeof(char) *2, 1,file);
  33.     fread(&header->size, sizeof(int), 1,file);
  34.     fread(&header->reserved1, sizeof(short), 1,file);
  35.     fread(&header->reserved2, sizeof(short), 1,file);
  36.     fread(&header->offset_pixel_array, sizeof(int), 1,file);
  37. }
  38. void readDIBHeader(FILE* file, struct DIB_Header* header) {
  39.     fread(&header->size, sizeof(int), 1,file);
  40.     fread(&header->width, sizeof(int), 1,file);
  41.     fread(&header->height, sizeof(int), 1,file);
  42.     fread(&header->planes, sizeof(short), 1,file);
  43.     fread(&header->bits_per_pixel, sizeof(short), 1,file);
  44.     fread(&header->compression, sizeof(int), 1,file);
  45.     fread(&header->image_size, sizeof(int), 1,file);
  46.     fread(&header->x_per_meter, sizeof(int), 1,file);
  47.     fread(&header->y_per_meter, sizeof(int), 1,file);
  48.     fread(&header->colors_in_table, sizeof(int), 1,file);
  49.     fread(&header->important_colors, sizeof(int), 1,file);
  50. }
  51. void readPixelsBMP(FILE* file, int width, int height, struct Pixel (**pArr)[width][height]) {
  52.     *pArr = malloc( sizeof(struct Pixel[width][height]) );
  53.     if (*pArr == NULL) {
  54.         printf("Error! Insufficient memory!");
  55.         return;
  56.     }
  57.     
  58.     int padding = (4 - ((3*width) % 4)) % 4;
  59.     for (int i = 0; i < width; i++) {
  60.         for (int j = 0; j < height; j++) {
  61.             //fread(*pArr, sizeof(struct Pixel), 1, file);
  62.             fread(&(*pArr)[i][j]->b, sizeof(unsigned char), 1, file);
  63.             //fread((*pArr)[i][j]->r, sizeof(unsigned char), 1, file);
  64.             //fread((*pArr)[i][j]->g, sizeof(unsigned char), 1, file);
  65.         }
  66.         if (padding) {
  67.             fseek(file, padding, SEEK_CUR);
  68.         }
  69.     }
  70.     fclose(file);
  71. }
  72. void writeBMPHeader(FILE* file, struct BMP_Header* header) {
  73.     fwrite(&header->signature, sizeof(char) *2, 1,file);
  74.     fwrite(&header->size, sizeof(int), 1,file);
  75.     fwrite(&header->reserved1, sizeof(short), 1,file);
  76.     fwrite(&header->reserved2, sizeof(short), 1,file);
  77.     fwrite(&header->offset_pixel_array, sizeof(int), 1,file);
  78. }
  79. void writeDIBHeader(FILE* file, struct DIB_Header* header) {
  80.     fwrite(&header->size, sizeof(int), 1,file);
  81.     fwrite(&header->width, sizeof(int), 1,file);
  82.     fwrite(&header->height, sizeof(int), 1,file);
  83.     fwrite(&header->planes, sizeof(short), 1,file);
  84.     fwrite(&header->bits_per_pixel, sizeof(short), 1,file);
  85.     fwrite(&header->compression, sizeof(int), 1,file);
  86.     fwrite(&header->image_size, sizeof(int), 1,file);
  87.     fwrite(&header->x_per_meter, sizeof(int), 1,file);
  88.     fwrite(&header->y_per_meter, sizeof(int), 1,file);
  89.     fwrite(&header->colors_in_table, sizeof(int), 1,file);
  90.     fwrite(&header->important_colors, sizeof(int), 1,file);
  91. }
  92. void writePixelsBMP(FILE* file, int width, int height, struct Pixel (**pArr)[width][height]) {
  93.     int padding = (4 - ((3*width) % 4)) % 4;
  94.     for (int i = 0; i < width; i++) {
  95.         for (int j = 0; j < height; j++) {
  96.             fwrite(*pArr, sizeof(struct Pixel), 1, file);
  97.         }
  98.         if (padding)
  99.             fwrite("0", sizeof(char),padding, file);
  100.     }
  101.     char eof = 0x00;
  102.     fwrite(&eof, sizeof(char), 1, file);
  103. }
  104.     
  105. int main() {
  106.     char* filename = "test1wonderbread.bmp";
  107.     char* output = "test3wonderbread.bmp";
  108.     FILE* file_input = fopen(filename, "rb");
  109.     FILE* file_output = fopen(output, "wb");
  110.     
  111.     struct BMP_Header* header = (struct BMP_Header*) malloc(sizeof(struct BMP_Header));
  112.     readBMPHeader(file_input, header);
  113.     struct DIB_Header* dib_header = (struct DIB_Header*) malloc(sizeof(struct DIB_Header));
  114.     readDIBHeader(file_input, dib_header);
  115.     
  116.     struct Pixel (*pArr)[dib_header->width][dib_header->height];
  117.     readPixelsBMP(file_input, dib_header->width, dib_header->height, &pArr);
  118.     
  119.     writeBMPHeader(file_output, header);
  120.     writeDIBHeader(file_output, dib_header);
  121.     //writePixelsBMP(file_output, dib_header->width, dib_header->height, &pArr);
  122.     printf("no errors");
  123.     return 0;
  124. }
c

2条答案

按热度按时间
mlnl4t2r

mlnl4t2r1#

发布的代码非常非常复杂，可能没有任何原因。
5 + 11次调用fread来获取位图头？5 + 11次调用fwrite来写相同的头？为什么会这样呢？

所有这些都是54字节？.

不算读取实际像素的调用...
我将在这里展示一种读取和写入位图的方法，包括代码和一些参数。这里的基本区别是位图的封装

**我将再次留下一篇长文章，因为我认为在这里有一个完整的代码来读取，绘制和编写C位图是有用的。

完全可以无视。

一个位图struct和几种方法

  1. typedef struct
  2. {
  3.     char    header[2];
  4.     int32_t fileSize;
  5.     int32_t reserved;
  6.     int32_t dataOffset;
  7. } BitmapFileHeader;
  9. typedef struct
  10. {
  11.     int32_t headerSize;
  12.     int32_t width;
  13.     int32_t height;
  14.     int16_t planes;
  15.     int16_t bitsPerPixel;
  16.     int32_t compression;
  17.     int32_t dataSize;
  18.     int32_t horizontalResolution;
  19.     int32_t verticalResolution;
  20.     int32_t colors;
  21.     int32_t importantColors;
  22. } BitmapInfoHeader;
  24. typedef struct
  25. {
  26.     BitmapFileHeader h_bmp;
  27.     BitmapInfoHeader h_info;
  28.     uint8_t*         pixel;
  29. } Bitmap;
  31.     Bitmap* bmp_create(unsigned w, unsigned h);
  32.     Bitmap* bmp_destroy(Bitmap* bmp);
  33.     int     bmp_fill(Bitmap*, uint8_t, uint8_t, uint8_t);
  34.     int     bmp_grad(Bitmap* bmp);
  35.     Bitmap* bmp_read(const char* filename);
  36.     int     bmp_setPixel(
  37.             Bitmap* bmp, int x, int y, uint8_t red, uint8_t green,
  38.             uint8_t blue);
  39.     int bmp_write(Bitmap* bmp, const char* filename);

bmp_grad在任何位图绘制区域上构建类似

的东西。考虑到它们的名字，其他函数做的是预期的事情。一个简单的（完整的）实现在文章的结尾。代码的测试和输出如下。

main()进行测试

下面的代码显示了正在使用的函数。该方案：

  • 创建1024x768 bmp
  • 用红色、绿色和蓝色填充位图，并将3个位图保存到磁盘。这是第一个的代码，red.bmp：
  1. res = bmp_fill(a_test, 255, 0, 0);  // red
  2.     fprintf(stderr, "\tbmp_fill returned %d\n", res);
  3.     res = bmp_write(a_test, "red.bmp");
  4.     fprintf(stderr, "\tbmp_write() returned %d\n", res);
  • 使用bmp_read从磁盘读取其中一个位图，然后将其保存为blueCopy.bmp中的副本
  1. Bitmap* a_copy = bmp_read("blue.bmp");
  2.     fprintf(stderr, "\tbmp_read() read a [%d x %d], size is %d\n", 
  3.         a_copy->h_info.width,
  4.         a_copy->h_info.height,
  5.         a_copy->h_bmp.fileSize);
  6.     res = bmp_write(a_copy, "blueCopy.bmp");
  7.     fprintf(stderr, "\tbmp_write() returned %d\n", res);
  • 这个的输出：
  1. bmp_read() read a [1024 x 768], size is 3145782
  2.         bmp_write() returned 0
  • 调用bmp_grad绘制条纹并将新位图保存为stripes.bmp。
  • bmp_setPixel用于在stripes.bmp的中心绘制一条11像素高的黑色线条，然后将位图保存为lineset_Pixel.bmp，如下所示

main.c代码

  1. #include "bitmap.h"
  2. int main(void)
  3. { 
  4.     Bitmap* a_test = bmp_create(1024, 768);
  5.     if (a_test == NULL)
  6.     {
  7.         fprintf(stderr, "\tbitmap not created\n");
  8.         return -1;
  9.     }
  10.     fprintf(stderr, "\tbitmap created ok!\n");
  11.     int res = 0;
  13.     res = bmp_fill(a_test, 255, 0, 0);  // red
  14.     fprintf(stderr, "\tbmp_fill returned %d\n", res);
  15.     res = bmp_write(a_test, "red.bmp");
  16.     fprintf(stderr, "\tbmp_write() returned %d\n", res);
  18.     res = bmp_fill(a_test, 0, 255, 0);  // green
  19.     fprintf(stderr, "\tbmp_fill() returned %d\n", res);
  20.     res = bmp_write(a_test, "green.bmp");
  21.     fprintf(stderr, "\tbmp_write() returned %d\n", res);
  23.     res = bmp_fill(a_test, 0, 0, 255);  // blue
  24.     fprintf(stderr, "\tbmp_fill() returned %d\n", res);
  25.     res = bmp_write(a_test, "blue.bmp");
  26.     fprintf(stderr, "\tbmp_write() returned %d\n", res);
  28.     Bitmap* a_copy = bmp_read("blue.bmp");
  29.     fprintf(stderr, "\tbmp_read() read a [%d x %d], size is %d\n", 
  30.         a_copy->h_info.width,
  31.         a_copy->h_info.height,
  32.         a_copy->h_bmp.fileSize);
  33.     res = bmp_write(a_copy, "blueCopy.bmp");
  34.     fprintf(stderr, "\tbmp_write() returned %d\n", res);
  35.     
  36.     res = bmp_grad(a_copy);
  37.     fprintf(stderr, "\tbmp_grad() returned %d\n", res);
  38.     res = bmp_write(a_copy, "stripes.bmp");
  39.     fprintf(stderr, "\tbmp_write() returned %d\n", res);
  41.     // draw a black line at the center of the bitmap
  42.     for (int i = 0; i < a_copy->h_info.width; i += 1)
  43.         for (int j = (a_copy->h_info.height / 2) - 5;
  44.                  j < (a_copy->h_info.height / 2) + 5; j+=1)
  45.         bmp_setPixel(a_copy, i, j, 0, 0, 0);
  46.     res = bmp_write(a_copy, "lineset_Pixel.bmp");
  47.     fprintf(stderr, "\tbmp_write() returned %d\n", res);
  49.     a_test = bmp_destroy(a_test);
  50.     a_copy = bmp_destroy(a_copy);
  51.     fprintf(stderr, "\t[end of tests]\n");
  52.     return 0;
  53. }

Bitmap.h头

  1. #pragma once
  2. #pragma pack(push, 2)
  3. #pragma pack(show)
  5. #include <stdint.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  9. typedef struct
  10. {
  11.     char    header[2];
  12.     int32_t fileSize;
  13.     int32_t reserved;
  14.     int32_t dataOffset;
  15. } BitmapFileHeader;
  17. typedef struct
  18. {
  19.     int32_t headerSize;
  20.     int32_t width;
  21.     int32_t height;
  22.     int16_t planes;
  23.     int16_t bitsPerPixel;
  24.     int32_t compression;
  25.     int32_t dataSize;
  26.     int32_t horizontalResolution;
  27.     int32_t verticalResolution;
  28.     int32_t colors;
  29.     int32_t importantColors;
  30. } BitmapInfoHeader;
  32. typedef struct
  33. {
  34.     BitmapFileHeader h_bmp;
  35.     BitmapInfoHeader h_info;
  36.     uint8_t*         pixel;
  37. } Bitmap;
  39.     Bitmap* bmp_create(unsigned w, unsigned h);
  40.     Bitmap* bmp_destroy(Bitmap* bmp);
  41.     int     bmp_fill(Bitmap*, uint8_t, uint8_t, uint8_t);
  42.     int     bmp_grad(Bitmap* bmp);
  43.     Bitmap* bmp_read(const char* filename);
  44.     int     bmp_setPixel(
  45.             Bitmap* bmp, int x, int y, uint8_t red, uint8_t green,
  46.             uint8_t blue);
  47.     int bmp_write(Bitmap* bmp, const char* filename);
  49. #pragma pack(pop)

一个可能的bitmap.c完整实现

  1. #pragma pack(push, 2)
  2. #pragma pack(show)
  3. #include "bitmap.h"
  5. Bitmap* bmp_create(unsigned w, unsigned h)
  6. {
  7.     Bitmap* one = (Bitmap*)calloc(1, sizeof(Bitmap));
  9.     one->h_bmp.dataOffset =
  10.         sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader);
  11.     one->h_bmp.fileSize =
  12.         one->h_bmp.dataOffset + (w * h * 4);
  13.     // fprintf(
  14.     //     stderr, "\tbmp_create(): file size is %u\n",
  15.     //     one->h_bmp.fileSize);
  16.     one->h_bmp.header[0] = 'B';
  17.     one->h_bmp.header[1] = 'M';
  19.     one->h_info.bitsPerPixel         = 32;
  20.     one->h_info.headerSize           = 40;
  21.     one->h_info.height               = h;
  22.     one->h_info.horizontalResolution = 2400;
  23.     one->h_info.planes               = 1;
  24.     one->h_info.verticalResolution   = 2400;
  25.     one->h_info.width                = w;
  26.     one->pixel                       = (uint8_t*)calloc(
  27.         1, (size_t)(w * h * 4 * sizeof(uint8_t)));
  28.     if (one->pixel == NULL) return NULL;
  29.     return one;
  30. };
  32. Bitmap* bmp_destroy(Bitmap* bmp)
  33. {
  34.     if (bmp == NULL) return NULL;
  35.     if (bmp->pixel != NULL) free(bmp->pixel);
  36.     free(bmp);
  37.     fprintf(stderr, "\tbitmap destroyed\n");
  38.     return NULL;
  39. }
  41. int bmp_fill(
  42.     Bitmap* bmp, uint8_t red, uint8_t green, uint8_t blue)
  43. {
  44.     if (bmp == NULL) return -1;
  45.     uint8_t* p = bmp->pixel;
  46.     for (int32_t i = 0;
  47.          i < bmp->h_info.width * bmp->h_info.height; i += 1)
  48.     {  // 32bpp
  49.         *p++ = blue;
  50.         *p++ = green;
  51.         *p++ = red;
  52.         *p++ = 0xFF;  // alpha
  53.     }
  54.     return 0;
  55. }
  57. int bmp_grad(Bitmap* bmp)
  58. {
  59.     // fill screen with 3 vertical stripes R G B
  60.     // color ranging from 0 to 255 in each line
  61.     if (bmp == NULL) return -1;
  62.     uint8_t  red   = 0;
  63.     uint8_t  green = 0;
  64.     uint8_t  blue  = 0;
  65.     uint8_t* p     = bmp->pixel;
  66.     for (int y = 0; y < bmp->h_info.height; y++)
  67.     {
  68.         uint8_t color_value =
  69.             (uint8_t)(255 * (double)y / bmp->h_info.height);
  70.         for (int x = 0; x < bmp->h_info.width; x++)
  71.         {
  72.             switch (x / (bmp->h_info.width / 3))
  73.             {
  74.                 case 0:
  75.                     red   = color_value;
  76.                     green = 0;
  77.                     blue  = 0;
  78.                     break;
  79.                 case 1:
  80.                     red   = 0;
  81.                     green = color_value;
  82.                     blue  = 0;
  83.                     break;
  84.                 default:
  85.                     red   = 0;
  86.                     green = 0;
  87.                     blue  = color_value;
  88.                     break;
  89.             }
  90.             *p++ = blue;
  91.             *p++ = green;
  92.             *p++ = red;
  93.             *p++ = 0XFF;
  94.         }
  95.     };
  96.     return 0;
  97. }
  99. Bitmap* bmp_read(const char* filename)
  100. {
  101.     FILE* in = fopen(filename, "rb");
  102.     if (in == NULL) return NULL;
  103.     // any size is ok
  104.     Bitmap* one = bmp_create(800, 600);
  105.     if (one == NULL)
  106.     {
  107.         fclose(in);
  108.         return NULL;
  109.     }
  110.     size_t size =
  111.         sizeof(BitmapFileHeader) + sizeof(BitmapInfoHeader);
  112.     size_t res = fread((void*)one, (size_t)(1), size, in);
  113.     if (res != size) return NULL;
  114.     // read ok: now adjust the pixels and H W to the actual
  115.     // values of this file
  116.     size = one->h_info.height * one->h_info.width *
  117.            4;  // 32bpp
  118.     uint8_t* area = (uint8_t*)malloc(size);
  119.     if (area == NULL)
  120.     {
  121.         fclose(in);
  122.         return (NULL);
  123.     };
  124.     free(one->pixel);
  125.     one->pixel = area;
  126.     res = fread((void*)one->pixel, (size_t)(1), size, in);
  127.     return one;
  128. }
  130. int bmp_setPixel(Bitmap* bmp,
  131.     int x, int y, uint8_t red, uint8_t green, uint8_t blue)
  132. {
  133.     if (bmp == NULL) return -1;
  134.     uint8_t* pPixel = bmp->pixel;
  135.     // get address of coordinates of x,y
  136.     pPixel += (y * 4) * bmp->h_info.width + (x * 4);
  137.     pPixel[0] = blue;
  138.     pPixel[1] = green;
  139.     pPixel[2] = red;
  140.     pPixel[3] = 0xFF;
  141.     return 0;
  142. }
  144. int bmp_write(Bitmap* bmp, const char* filename)
  145. {
  146.     FILE* out = fopen(filename, "wb");
  147.     if (out == NULL) return -1;
  148.     size_t res = 0;
  149.     res        = fwrite(
  150.         &bmp->h_bmp, (size_t)1, sizeof(BitmapFileHeader),
  151.         out);
  152.     res = fwrite(
  153.         &bmp->h_info, (size_t)1, sizeof(BitmapInfoHeader),
  154.         out);
  155.     size_t size =
  156.         (bmp->h_info.width * bmp->h_info.height * 4);
  157.     res = fwrite(
  158.         (const void*)bmp->pixel, (size_t)(1), size, out);
  159.     if ( size != res )
  160.     { 
  161.         fclose(out);
  162.         fprintf(stderr, "\tbmp_write() write %zd. %zd expected\n",res, size);
  163.         fclose(out);
  164.         return -2;    }
  165.     res = fclose(out);
  166.     return 0;
  167. }
  169. #pragma pack(pop)

注意：在阅读和写入位图数据时，不要忘记将结构体与字边界对齐。它只是在编译器中使用#pragma或类似的设置

本例输出

  1. bitmap created ok!
  2.         bmp_fill returned 0
  3.         bmp_write() returned 0
  4.         bmp_fill() returned 0
  5.         bmp_write() returned 0
  6.         bmp_fill() returned 0
  7.         bmp_write() returned 0
  8.         bmp_read() read a [1024 x 768], size is 3145782
  9.         bmp_write() returned 0
  10.         bmp_grad() returned 0
  11.         bmp_write() returned 0
  12.         bmp_write() returned 0
  13.         bitmap destroyed
  14.         bitmap destroyed
  15.         [end of tests]

一些位图将被写入磁盘。

为什么这样可能更容易？

例如，bmp_write()代码

  1. int bmp_write(Bitmap* bmp, const char* filename)
  2. {
  3.     FILE* out = fopen(filename, "wb");
  4.     if (out == NULL) return -1;
  5.     size_t res = 0;
  6.     res        = fwrite(
  7.         &bmp->h_bmp, (size_t)1, sizeof(BitmapFileHeader),
  8.         out);
  9.     res = fwrite(
  10.         &bmp->h_info, (size_t)1, sizeof(BitmapInfoHeader),
  11.         out);
  12.     size_t size = (bmp->h_info.width * bmp->h_info.height * 4);
  13.     res = fwrite(
  14.         (const void*)bmp->pixel, size,
  15.         (size_t)(1), out);
  16.     res = fclose(out);
  17.     return 0;
  18. }

封装位图使事情更容易编写，测试和阅读。

bmp_setPixel作为（另一个）示例

  1. int bmp_setPixel(Bitmap* bmp,
  2.     int x, int y, uint8_t red, uint8_t green, uint8_t blue)
  3. {
  4.     if (bmp == NULL) return -1;
  5.     uint8_t* pPixel = bmp->pixel;
  6.     // get address of coordinates of x,y
  7.     pPixel += (y * 4) * bmp->h_info.width + (x * 4);
  8.     pPixel[0] = blue;
  9.     pPixel[1] = green;
  10.     pPixel[2] = red;
  11.     pPixel[3] = 0xFF;
  12.     return 0;
  13. }

用这种方式编写可以很容易地在位图上构建绘图原语。理解这一点的关键是要看到，

  1. pPixel += (y * 4) * bmp->h_info.width + (x * 4);

将(x,y)位图坐标转换为struct中的像素地址

展开查看全部
赞(0）分享  回复(0）举报  2023-10-16
hlswsv35

hlswsv352#

你有这么多层次的间接.
(*pArr)[i][j]是一个指向一维数组的指针。
您可以访问整个结构

  1. (*(*pArr))[i][j] 
  2. (**pArr)[i][j] 
  3. (*pArr)[0][i][j]
  4. pArr[0][0][i][j]

在fread中：

  1. fread(&(*(*pArr))[i][i], sizeof((*(*pArr))[i][i]), 1, file);
  2.     fread(&(**pArr)[i][j],   sizeof((**pArr)[i][j]),   1, file);
  3.     fread(&(*pArr)[0][i][i], sizeof((*pArr)[0][i][i]), 1, file);
  4.     fread(&pArr[0][0][i][i], sizeof(pArr[0][0][i][i]), 1, file);

或访问特定成员

  1. fread(&(*(*pArr))[i][i].r, sizeof((*(*pArr))[i][i].r), 1, file);
  2.     fread(&(**pArr)[i][j].r,   sizeof((**pArr)[i][j].r),   1, file);
  3.     fread(&(*pArr)[0][i][i].r, sizeof((*pArr)[0][i][i].r), 1, file);
  4.     fread(&pArr[0][0][i][i].r, sizeof(pArr[0][0][i][i].r), 1, file);

使用对象而不是sizeof中的类型。例如，如果您将成员更改为另一种类型，则转换器将自动更改它。

展开查看全部
赞(0）分享  回复(0）举报  2023-10-16
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com