在C中释放分配给超长字符串（char*）的内存？

请，我需要帮助释放分配给一个很长字符串的内存。我已尝试将代码缩减到包含我的问题的这一小部分：

#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <limits.h>

#define N 6
#define E 1024

int M[N][N][N], R[N*N][N], C[N*N][N], F[N*N][N];

void init_rcf() {
    int i, j, k, p;

    p = 0;
    for(j=0; j<N; j++) {
        for(k=0; k<N; k++) {
            for(i=0; i<N; i++) 
                R[p][i] = M[i][j][k];
            p++;
        }
    }

    p = 0;
    for(i=0; i<N; i++) {
        for(k=0; k<N; k++) {
            for(j=0; j<N; j++)
                C[p][j] = M[i][j][k];
            p++;
        }
    }

    p = 0;
    for(i=0; i<N; i++) {
        for(j=0; j<N; j++) {
            for(k=0; k<N; k++)
                F[p][k] = M[i][j][k];
            p++;
        }
    }
}

char *bin(int n, int p) {
    int c, d, count;
    char *pointer;
    count = 0;
    pointer = (char*)malloc(p+1);

    for (c = p-1;c >= 0;c--) {
        d = n >> c;
        if (d & 1) 
            *(pointer+count) = 1 + '0';
        else 
            *(pointer+count) = 0 + '0';
        count++;
    }
    *(pointer+count) = '\0';
    return  pointer;
}

int f0(int n) {
    return ceil(log2(n+1)); 
}

int f1() {
    int sum, max = 0;
    for(int k=0;k<N;k++) {
        for(int j=0;j<N;j++) {
            for(int i=0;i<N-1;i++) {
                sum = M[i][j][k] + M[i+1][j][k]; 
                if (sum > max) 
                    max = sum; 
            }
        }   
    }
    return max;
}

int f2() {
    int sum, max = 0;
    for(int k=0;k<N;k++) {
        for(int i=0;i<N;i++) {
            for(int j=0;j<N-1;j++) {
                sum = M[i][j][k] + M[i][j+1][k]; 
                if (sum > max) 
                    max = sum; 
            }
        }   
    }
    return max;
}

int f3() {
    int sum, max = 0;
    for(int j=0;j<N;j++) {
        for(int i=0;i<N;i++) {
            for(int k=0;k<N-1;k++) {
                sum = M[i][j][k] + M[i][j][k+1]; 
                if (sum > max) 
                    max = sum; 
            }
        }   
    }
    return max;
}

int f4() {
    int m1 = f1(),  m2 = f2(), m3 = f3(); 
    if ((m1 >= m2) && (m1 >= m3)) return m1;
    if ((m1 <= m2) && (m2 >= m3)) return m2;
    if ((m1 <= m3) && (m2 <= m3)) return m3;
}

char *g_fxn() {
    char *g = (char *) malloc(1 + (N*N*N)*3); 
    int k = f0(f4());

    init_rcf();
    strcpy(g,"");            
    for(int i=0; i<N*N; i++) 
        for(int j=0; j<N; j++) 
            strcat(g,bin(R[i][j],k));
    for(int i=0; i<N*N; i++) 
        for(int j=0; j<N; j++) 
            strcat(g,bin(C[i][j],k));
    for(int i=0; i<N*N; i++) 
        for(int j=0; j<N; j++) 
            strcat(g,bin(F[i][j],k));
    return g;
}

void convert2bin(char *file_in) {
    const char *FILENAME_IN = file_in;
    const char FILENAME_OUT[] = "temp.txt";
    char c, d; 
    int k=0;

    FILE *infile;
    FILE *outfile;

    infile = fopen(FILENAME_IN, "rb");
    outfile = fopen(FILENAME_OUT, "w");
    if(infile == NULL){
        fprintf(stderr, "Error: Source file not found.\n");
        exit(EXIT_FAILURE);
    }

    while((c = fgetc(infile)) != EOF){
        k++;
        unsigned n = (sizeof(c) * CHAR_BIT) - 1; 
        for (int i=0; i<=n; i++) { 
            int m = (c >> (n-i)) & 1; 
            d = '0'+m;          
            fwrite(&d, 1, sizeof(d), outfile);
        }
    }

    if (k < E) {
        d = '1';
        fwrite(&d, 1, sizeof(d), outfile);
        for (int i=k; i<=E; i++) { 
            d = '0';            
            fwrite(&d, 1, sizeof(d), outfile);
        }
    }

    fclose(infile);
    fclose(outfile);
}

void digest() {
    const char *FILENAME_IN = "temp.txt";
    const char FILENAME_OUT[] = "digest.txt";

    int size = N*N*N; // size of message to construct N*N*N matrix
    char c, msg0[size], *msgf; 

    FILE *infile;
    FILE *outfile;

    infile = fopen(FILENAME_IN, "r");
    outfile = fopen(FILENAME_OUT, "wb");
    if(infile == NULL){
        fprintf(stderr, "Error: Source file \"temp.txt\" not found.\n");
        exit(EXIT_FAILURE);
    }

    int quit = 0;
    while (quit == 0) {
        msgf = (char *) malloc(1 + (size)*3);
        strcpy(msgf, ""); 
        strcpy(msg0, "");
        int p = 0;
        while(((c = fgetc(infile)) != EOF) && (p < size)) {
            msg0[p++] = c;
        }

        if(c == EOF) quit = 1;
        if (p > 0) {
            if (p < size) {
                msg0[p] = '1';
                for(int i=p+1; i<size; i++) 
                    msg0[i] = '0';
            }

            for (int k=0; k<N; k++)
                for (int j=0; j<N; j++)
                    for (int i=0; i<N; i++) {
                        c = msg0[i + N * (j + N * k)];
                        if (c == '0')
                            M[i][j][k] = 0;
                        else 
                            M[i][j][k] = 1;
                    }

            strcpy(msgf, g_fxn());             
            int q = 0;

            while (q<strlen(msgf)) {
                int d;
                char b = 0;
                for (int r=0; r<8; r++) {
                    if (msgf[q++] == '0') 
                        d = 0;
                    else 
                        d = 1;
                    b = ((b<<1) | d);
                }
                fwrite(&b, 1, 1, outfile);
                b = 0;
            }
        }
    }

    free(msgf);
    fclose(infile);
    fclose(outfile);
}

int main(int argc, char *argv[]){
    if (argc!=2) {
        fprintf(stderr, "Error: Provide name of one source file.\n");
        exit(EXIT_FAILURE);
    }

    char *clear_file = argv[1];

    convert2bin(clear_file);

    digest();

    printf("File successfully digested!\n");

    return(0);
}

#包括
#包括
#包括
#包括
#包括
#定义n6
#定义E 1024
int M[N][N][N]、R[N*N][N]、C[N*N][N]、F[N*N][N]；
void init_rcf（）{
int i，j，k，p；
p=0；
对于（j=0；jmsgf，多次在函数digest（）的while循环中分配：

msgf = (char *) malloc(1 + (size)*3);

但free（）只在循环后调用一次：

free(msgf);

这是我发现的至少一个内存泄漏。
有些函数分配了内存，但没有像中那样释放内存-

char*g_fxn（）
和
char*bin（int n，int p）

编辑
在这些函数中返回指针时，可以使用
goto
语句

下面的例子说明了如何解决您的问题-

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char lol(char c[]);

char lol(char c[])
{ 
  char a[6]="hello";
  char *p=malloc(sizeof(a));
  p=a;
  memcpy(c,p,strlen(a));
  goto DONE;

  DONE:
  free(p);
  return c;
}

int main()
{
   char b[5];
   lol(b);
   printf("%s",b);
  return 0;
}

#包括
#包括
#包括
char-lol（char-c[]）；
字符lol（字符c[]
{ 
字符a[6]=“你好”；
char*p=malloc（sizeof（a））；
p=a；
memcpy（c，p，strlen（a））；
去做；
完成：
自由基（p）；
返回c；
}
int main（）
{
charb[5]；
lol（b）；
printf（“%s”，b）；
返回0；
}
如果函数分配内存并返回结果指针，而不是释放内存，则调用函数必须确保在不再需要时释放该指针。在strcpy（msgf，g_fxn（））

情况下，这可能如下所示：

char *tmp = g_fxn();
strcpy(msgf, tmp);
free(tmp);

---

通常，每次从

malloc（）

中获取指向内存的指针时，一旦不再需要它，就必须稍后将指向该内存的指针传递到

free（）

。

首先始终选中malloc返回。如果为NULL，则未分配指针。缩进非常混乱！在

convert2bin（）中更改
c
）

to

int c

nad重新写入

unsigned n=（sizeof（c）*字符位）-1；

。缩进代码时，切勿使用制表符，因为每个编辑器/文字处理器对制表符宽度/制表位有不同的设置。建议每行仅放置一条代码语句，以便于我们阅读。发布的代码不会编译。当询问运行时问题时，发布干净编译的代码。宏字符位未定义ed（因为适当的头文件尚未包含）。函数f4（）的路径没有以“return value；”语句结尾。此行：'while（qThe

bin（）

函数似乎也分配了从未释放的内存。不需要释放bin（）中的内存）函数，您还可以在使用返回值（字符串）后释放它们。为此，您必须将返回的指针存储在缓冲区变量中，然后使用缓冲区变量，然后释放它（每次调用bin（）时）@RhinoDevel谢谢你的评论，你是对的，但我不能这样做。在while循环中释放msgf-就在关闭循环之前-即使对于1字节的输入文件也会使其崩溃！@davidlaport至于

bin（）中分配的内存

函数这是我遇到的最大问题，我无法释放

g

，因为这正是函数返回的内容。我不知道如何释放

bin（）中分配的内存

function…@RhinoDevel感谢您的建议。但有一个问题：这是否意味着我必须使用全局变量作为缓冲区？我这样问是因为我认为我无法释放它。谢谢@ameyCU，这正是我遇到的问题：在

g_fxn（）中

释放while循环中分配给

msgf

的内存会使其崩溃并进入

bin（）

我不知道如何释放分配给我要返回的变量的内存？！@IT\u请检查编辑。我试图解决您的问题，您可以通过修改它在程序中使用类似的逻辑。感谢这个想法，我将探索它，看看它是如何运行的，尽管我不太确定如何在我的代码中调整它。不过，我会给它一些提示谢谢@sth，我也试过了，但是在这种情况下，1字节的输入文件会崩溃。