C语言实现PPM(P3)图像读写及内存释放遇输出异常求助

Let's walk through how to implement your readData, writeData, and freeImage functions correctly—since your current code is just a framework (no actual function implementations), that's almost certainly why you're not getting valid output.

First, let's start with your existing type definitions (so we're working with the same structure):

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <string.h>
#include <ctype.h> // Needed for whitespace/comment handling in readData

typedef struct Color { uint8_t R; uint8_t G; uint8_t B; } Color;
typedef struct Image { Color **image; uint32_t rows; uint32_t cols; } Image;

//Loads an image from a ppm file, and converts to an Image object
extern Image *readData(char *filename);
//Writes an image to stdout
extern void writeData(Image *image);
//Frees an image and all its associated data
extern void freeImage(Image *image);

Now let's build out each function properly, with notes on common pitfalls to avoid:

1. Implementing readData #

Binary PPM (format P6) is the most common and efficient variant—we'll focus on this (text PPM P3 is rarely used for real images). The PPM format requires:

• Magic number (P6)
• Optional comment lines (starting with #)
• Width (columns), height (rows)
• Maximum color value (almost always 255 for 8-bit images)
• Raw RGB byte data

Here's a robust implementation:

Image *readData(char *filename) {
    FILE *fp = fopen(filename, "rb");
    if (!fp) {
        perror("Failed to open input file");
        return NULL;
    }

    // Validate magic number
    char magic[3];
    if (fscanf(fp, "%2s", magic) != 1 || strcmp(magic, "P6") != 0) {
        fprintf(stderr, "Error: Only binary PPM (P6) format is supported\n");
        fclose(fp);
        return NULL;
    }

    // Skip comments and whitespace (critical—PPM files often have comments)
    int c;
    while ((c = fgetc(fp)) != EOF && (isspace(c) || c == '#')) {
        if (c == '#') {
            // Skip entire comment line
            while ((c = fgetc(fp)) != EOF && c != '\n');
        }
    }
    ungetc(c, fp); // Put back the non-comment/whitespace character for header reading

    // Read image dimensions and max color value
    uint32_t cols, rows, max_val;
    if (fscanf(fp, "%" SCNu32 " %" SCNu32 " %" SCNu32, &cols, &rows, &max_val) != 3) {
        fprintf(stderr, "Error: Invalid PPM header data\n");
        fclose(fp);
        return NULL;
    }
    if (max_val != 255) {
        fprintf(stderr, "Error: Only 8-bit PPM (max value 255) is supported\n");
        fclose(fp);
        return NULL;
    }

    // Skip the final whitespace/newline before pixel data (easy to miss!)
    while ((c = fgetc(fp)) != EOF && isspace(c));
    ungetc(c, fp);

    // Allocate Image struct
    Image *img = malloc(sizeof(Image));
    if (!img) {
        perror("Failed to allocate Image struct");
        fclose(fp);
        return NULL;
    }
    img->cols = cols;
    img->rows = rows;

    // Allocate row pointers + single block for pixel data (more efficient than per-row allocation)
    img->image = malloc(rows * sizeof(Color *));
    if (!img->image) {
        perror("Failed to allocate row pointers");
        free(img);
        fclose(fp);
        return NULL;
    }
    Color *pixels = malloc(rows * cols * sizeof(Color));
    if (!pixels) {
        perror("Failed to allocate pixel data");
        free(img->image);
        free(img);
        fclose(fp);
        return NULL;
    }
    // Map row pointers to the single pixel block
    for (uint32_t i = 0; i < rows; i++) {
        img->image[i] = &pixels[i * cols];
    }

    // Read raw pixel data
    size_t bytes_read = fread(pixels, sizeof(Color), rows * cols, fp);
    if (bytes_read != rows * cols) {
        fprintf(stderr, "Error: Incomplete pixel data read\n");
        free(pixels);
        free(img->image);
        free(img);
        fclose(fp);
        return NULL;
    }

    fclose(fp);
    return img;
}

Key fixes here:

• Properly skips comments and whitespace in the header (a common source of corrupted data)
• Uses a single block for pixel data (avoids memory fragmentation and simplifies cleanup)
• Adds error checking for every allocation and file operation

2. Implementing writeData #

We need to output the PPM header followed by raw pixel data to stdout. Note: On Windows, you may need to force binary mode for stdout to avoid corrupting byte data.

void writeData(Image *image) {
    if (!image || !image->image) {
        fprintf(stderr, "Error: Invalid Image pointer passed to writeData\n");
        return;
    }

    // Write PPM header (strict formatting required!)
    printf("P6\n");
    printf("%" PRIu32 " %" PRIu32 "\n", image->cols, image->rows);
    printf("255\n");

    // Write raw pixel data (using the single block we allocated in readData)
    Color *pixels = image->image[0];
    fwrite(pixels, sizeof(Color), image->rows * image->cols, stdout);

    // Ensure all data is flushed to stdout
    fflush(stdout);
}

Common mistakes to avoid:

• Forgetting newlines in the header (PPM requires proper line breaks)
• Writing in text mode on Windows (add setmode(fileno(stdout), O_BINARY); at the start of the function, plus includes for <fcntl.h> and <sys/stat.h>)

3. Implementing freeImage #

We need to free memory in reverse order of allocation: first the pixel data block, then row pointers, then the Image struct itself.

void freeImage(Image *image) {
    if (!image) return; // Guard against NULL pointers

    // Free the single pixel data block (accessed via the first row pointer)
    if (image->image && image->image[0]) {
        free(image->image[0]);
    }
    // Free row pointers
    free(image->image);
    // Free the Image struct
    free(image);
}

Critical note:

• Don't free row pointers before the pixel data—this would leave you with no way to access the underlying pixel block, leading to memory leaks.

Testing the Code #

Add a simple main function to test the workflow:

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <input.ppm>\n", argv[0]);
        return 1;
    }

    Image *img = readData(argv[1]);
    if (!img) return 1;

    writeData(img);
    freeImage(img);

    return 0;
}

Compile and run with:

gcc -o ppm_processor ppm_processor.c
./ppm_processor input.ppm > output.ppm

You can verify the output is correct by comparing input.ppm and output.ppm with a tool like cmp or opening output.ppm in an image viewer.

内容的提问来源于stack exchange，提问作者Simran Munot