c - C程序内存泄漏，看不到在哪里释放内存

Question

我正在编写一个 C 程序来生成 key 并在加密函数中测试它们。然而，由于我以前从未编写过 C 程序，并且我完全不习惯手动管理内存，所以我遇到了问题。我有内存泄漏，说实话，我不知道如何解决它。我知道我需要在某个时候释放内存，但直到我运行完所有键并且在完成所有键之前我就用完了内存。用不同的语言编写程序不是一种选择，所以请不要建议这样做。泄漏的代码如下所示，任何帮助将不胜感激。

编辑:我知道我没有调用自由函数来释放内存。我不知道可以把它放在哪里，因为我需要内存，直到我运行完所有键为止。将其放在循环之外并不能解决问题，因为泄漏发生在循环内部

第二次编辑:发布了完整的程序。由于 DES 加密函数(我没有编写)的工作原理，我无法选择使用除显示的数据结构之外的数据结构(即 bool 数组)

#include <stdio.h>
#include <stdlib.h>
#include "des.h"

void dec2bin(bool *testaRR, bool *to_return, int convert);

int main(int argc, const char * argv[])
{

// insert code here...
bool testKey[56] = {
    0, 1, 0, 0, 0, 0, 0, 1,
    0, 1, 0, 0, 0, 0, 0, 1,
    0, 1, 0, 0, 0, 0, 0, 1,
    0, 1, 0, 0, 0, 0, 0, 1,
    0, 1, 0, 0, 0, 0, 0, 1,
    0, 1, 0, 0, 0, 0, 0, 1,
    0, 1, 0, 0, 0, 0, 0, 1
};
bool testKey2[56] = {//intuitive key reversed for testing
    1, 0, 0, 0, 0, 0, 1, 0,
     1, 0, 0, 0, 0, 0, 1, 0,
     1, 0, 0, 0, 0, 0, 1, 0,
     1, 0, 0, 0, 0, 0, 1, 0,
     1, 0, 0, 0, 0, 0, 1, 0,
     1, 0, 0, 0, 0, 0, 1, 0,
    1, 0, 0, 0, 0, 0, 1, 0
};
 bool output[64];

 bool input[64] = {//the reverse of below...  DES bits are numbered left to right, in order of least to most significant so we must enter the bit values in reverse.
     //forexample the binary vale of N is 01001110 but below is displayed as 01110010
 1, 0, 0, 0, 1, 1, 0, 0,//1
 0, 0, 0, 0, 1, 1, 0, 0,//0
 1, 1, 0, 0, 0, 0, 1, 0,//C
 1, 0, 1, 0, 0, 0, 1, 0,//E
 1, 1, 0, 0, 1, 0, 1, 0,//S
 0, 0, 1, 0, 1, 0, 1, 0,//T
 1, 0, 1, 0, 0, 0, 1, 0,//E
 0, 1, 1, 1, 0, 0, 1, 0 //N
 };
 int y = sizeof(input);
 printf("(Input MSG: ");
 for (int i = y-4; i >= 0; i-=4)
 printf("%X", input[i]+2*input[i+1]+4*input[i+2]+8*input[i+3]);//this is the conversion to    hex code
 printf(")\n");

/*
 use char[] to store the key as set of 
 */
/*bool input[64] = {//this is the given plaintext message in the intuitive order (opposite of what it is)   
    0, 1, 0, 0, 1, 1, 1, 0,//N
    0, 1, 0, 0, 0, 1, 0, 1,//E

    0, 1, 0, 1, 0, 1, 0, 0,//T
    0, 1, 0, 1, 0, 0, 1, 1,//S
    0, 1, 0, 0, 0, 1, 0, 1,//E
    0, 1, 0, 0, 0, 0, 1, 1,//C
    0, 0, 1, 1, 0, 0, 0, 0,//0
    0, 0, 1, 1, 0, 0, 0, 1 //1
};


int y = sizeof(input);
printf("(Input MSG: ");
for (int j = 0; j < y; j+=4)
    printf("%X", input[j+3]+2*input[j+2]+4*input[j+1]+8*input[j]);//this is the conversion to hex code
printf(")\n");*/
bool test [8];
bool returned[8];
char keyphrase [8];
keyphrase[7] = 0;

for(int start = 65; start<=90; start++)
{
     //dec2bin(test, returned, start);
 keyphrase[0] = start;
    for(int two = 65; two<=90; two++){
        keyphrase[1]=two;
        for(int three = 65; three<=90; three++){
            keyphrase[2]=three;
            for(int four = 65; four<=90; four++){
                keyphrase[3]=four;
                for(int five = 65;five<=90;five++){
                    keyphrase[4]=five;
                    for( int six = 65; six <=90; six++){
                        keyphrase[5]=six;
                        for(int seven = 65; seven <=90; seven++){
                            keyphrase[6]=seven;
                            printf("%s \n", keyphrase);
                        }

                            }}
                        }
                    }
                }
 //once i fix the memory leak I will be calling the EncryptDes Function here and checking the outputblk agains the given cipher text
}
free(keyphrase);

int k = sizeof(testKey);
printf("(Test Key: ");
for (int z = 0; z < k; z+=7)
    printf("%d", testKey[z+7]+2*testKey[z+6]+4*testKey[z+5]+8*testKey[z+4]+16*testKey[z+3]+32*testKey[z+2]+64*testKey[z+1]+ 128*testKey[z]);//this is the conversion to hex code
printf(")\n");

//loop on the key (starting at
EncryptDES(testKey, output, input, 0);
int x = sizeof(output);
printf("(Output MSG: ");
for (int i = 0; i < x; i+=4)
    printf("%X", output[i+3]+2*output[i+2]+4*output[i+1]+8*output[i]);//this is the conversion to hex code
printf(")\n");


return 0;
}
void dec2bin (bool *testaRR, bool *to_return, int convert)

{
 printf("%d : ", convert);
 printf("%c", convert);
 printf("\n ");

//bool testaRR [8];
for(int st = 0; st<8; st++){
    testaRR[st] = convert%2;
    to_return[7-st] = testaRR[st];
    //printf("%d :", 7-st);
   //printf(" %d spot ", st);
    convert = convert/2;
    //testaRR stores the arrays in one direction
    //to_return stores them in the other
    //Example:
    //65 = 01000001 testaRR least significant on the far right (m0st sig is in index 7)better for storage and keeping track of where the bits actually are in binary
    //65 = 10000010 to_return least significant on the far left (same as DES) (most significant bit is index 0) good for printing to screen
}

Answer 1

这里不需要动态内存管理。

开始于

char keyphrase[8];
keyphrase[7]=0;

而不是你的malloc，你就可以开始了。您的最高数组索引是 7(终止 NUL)，因此您需要一个包含 8 个项目的数组 (0..7)。

如果你真的想使用malloc，只需在最后加上free()就可以了，但你需要malloc 8字符并将 keyphrase[7] 设置为 0，以仍然执行终止 NUL。

这是一个经过测试的有效版本:

#include <stdio.h>

/* compile with gcc -Wall -std=c99 keyphrase.c -o keyphrase */

int
main (int argc, char **argv)
{
  char keyphrase[8];
  keyphrase[7] = 0;
  for (int start = 65; start <= 90; start++)
    {
      //dec2bin(test, returned, start);
      keyphrase[0] = start;
      for (int two = 65; two <= 90; two++)
        {
          keyphrase[1] = two;
          for (int three = 65; three <= 90; three++)
            {
              keyphrase[2] = three;
              for (int four = 65; four <= 90; four++)
                {
                  keyphrase[3] = four;
                  for (int five = 65; five <= 90; five++)
                    {
                      keyphrase[4] = five;
                      for (int six = 65; six <= 90; six++)
                        {
                          keyphrase[5] = six;
                          for (int seven = 65; seven <= 90; seven++)
                            {
                              keyphrase[6] = seven;
                              printf ("%s \n", keyphrase);
                            }
                        }
                    }
                }
            }
        }
    }
}