Free - не удаляется память - C++ - Ответ 5975687

#define _CRT_SECURE_NO_WARNINGS
#include <string.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>
#include <locale.h>
//////////////////////////////////////////////////////////////////////////
#define ANSWER_EXIT 0
#define ANSWER_ADD 1
#define ANSWER_DELETE 2
#define ANSWER_PRINT 3
#define ANSWER_FIND 4
#define ANSWER_PRINT_MORE_ITEMS 5
#define ANSWER_EMPTY 6
//////////////////////////////////////////////////////////////////////////
#define true 1
#define false 0
#define bool int
#define MaxSizeItem  100 // максимальный размер списка
#define DefautDataSize  5 // количество начальных эллементов
#define MaxStringSizeData  100 // максимальная длинна строки начальных эллементов
#define FILE_NOT_NAME_SAVE ""
const int MaxFileName = 256;
const int MaxString = 2000; // максимальный размер буфера
//////////////////////////////////////////////////////////////////////////
char DataString[DefautDataSize][MaxStringSizeData] = {"значение1","значение2","значение3","значение4","значение5"};//информаия начальных эллементов
int DataKey[DefautDataSize] = {1,2,3,4,5};//ключи начальных эллементов
char *buf;//буфер
char *g_nameFileOpen;
//////////////////////////////////////////////////////////////////////////
 
 
 
struct Item
{
    int key;
    int length;
    int offset;
    char *info;
}; 
struct Item Items[MaxSizeItem];
int ItemSize;
//////////////////////////////////////////////////////////////////////////
bool Load(char *nameFileData_) //требуется для вычесления нового смещения
{
    int i;
    int size = -1;
 
    FILE * fileInit ;
    if ((fileInit = fopen(nameFileData_, "rb"))==NULL) {
        printf("He удается открыть файл.\n");
        return false;
    }
 
    fread(&size,sizeof(int),1,fileInit);
    if(size < 0)
    {
        ItemSize = 0;
        return true;
    }
    ItemSize = size;// размер списка
    //////////////////////////////////////////////////////////////////////////
    for(i = 0; i < ItemSize; i++)
    {
        fread(&Items[i].offset,sizeof(int),1,fileInit);
        fread(&Items[i].length,sizeof(int),1,fileInit);
        fread(&Items[i].key,sizeof(int),1,fileInit);
        Items[i].info = (char*)malloc(sizeof(char) * 7 );//память для строки
        fread(Items[i].info,sizeof(char),Items[i].length,fileInit);
        Items[i].info[Items[i].length] = 0;
    }
    //////////////////////////////////////////////////////////////////////////
    fclose(fileInit);
    return true;
}
 
void Save(char *nameFileSave)
{
    FILE *fileSave;
    int i ;
 
    fileSave = fopen(nameFileSave,"wb");
 
    fwrite(&ItemSize,sizeof(int),1,fileSave);
    for(i = 0; i < ItemSize; i++)
    {
        fwrite(&Items[i].offset,sizeof(int),1,fileSave);
        fwrite(&Items[i].length,sizeof(int),1,fileSave);
        fwrite(&Items[i].key,sizeof(int),1,fileSave);
        fwrite(Items[i].info,sizeof(char),Items[i].length,fileSave);
 
    }
    fclose(fileSave);
}
//////////////////////////////////////////////////////////////////////////
 
bool init(char *nameFileData_)
{
    
//////////////////////////////////////////////////////////////////////////
    
    buf = (char*)malloc(sizeof(char) * ( MaxString + 1) ); // временный буфер для считывания
    return Load(nameFileData_);
    
}
//////////////////////////////////////////////////////////////////////////
 
int FindOneKey(int key)// ищем ключ, возвращаем его порядковый номер в списке
{
    #define NO_ITEM -1
    int i;
    for(i = 0; i < ItemSize; i++)//обход списка
    {
        if (Items[i].key == key)
            return i;//порядковый номер
    }
    return  NO_ITEM;//неудача
};
//////////////////////////////////////////////////////////////////////////
 
bool CheckKey(int key)// проверяем ключ на существование
{
    int i;
    for(i = 0; i < ItemSize; i++)
    {
        if (Items[i].key == key)
            return true; // true , false и bool не существует в СИ, смотрите директивы
    }
    return false; // true , false и bool не существует в СИ, смотрите директивы
}
//////////////////////////////////////////////////////////////////////////
 
void AddItem()
{
    #define REENTERED 1
    int key;
    //////////////////////////////////////////////////////////////////////////
    if(ItemSize == MaxSizeItem)
    {
        puts("список заполнен");
        return;
    }
    puts("выберите ключ");
    while (!scanf("%i", &key))
    {
        scanf( "%*[^\n]" ); scanf( "%*c" );// не много магии
        puts("не корректный ввод, повторите операцию");
    }
    while(CheckKey(key))// проверяем ввод ключа
    {
        puts("такой ключ уже существует, 1 - для ввода нового ключа, любой другой символ для выхода ");
        if(!scanf("%i",&key)) // введенно не число
            return;
        if(key == REENTERED) //введенна единица
        {
            puts("выберите ключ");
            while (!scanf("%i", &key)) 
            {
                scanf( "%*[^\n]" ); scanf( "%*c" );// не много магии
                puts("не корректный ввод, повторите операцию");
            }   
        }
        else // введенна не единица
        {
            return;
        }
    }
    //////////////////////////////////////////////////////////////////////////
 
    printf("введите информацию, максимальнй размер %i символа/символов \r\n", MaxString );
        scanf( "%*[^\n]" ); scanf( "%*c" );//обязательно прочистим после printf
    gets(buf);// новая информация
    Items[ItemSize].key = key;
    Items[ItemSize].info = (char*)malloc(sizeof(char) * ( strlen(buf) + 1)); 
    Items[ItemSize].length = strlen(buf);
    memcpy(Items[ItemSize].info,buf,Items[ItemSize].length);
    Items[ItemSize].info[Items[ItemSize].length] = 0;
    if(!ItemSize)
    {
        Items[ItemSize].offset = sizeof(int);
    }
    else
    {
        Items[ItemSize].offset = Items[ItemSize-1].offset + sizeof(int) * 3 + Items[ItemSize - 1].length;;
    }
    ItemSize++;
    Save(g_nameFileOpen);
}
//////////////////////////////////////////////////////////////////////////
 
void DeleteItem()
{
    #define REENTERED 1
    #define NO_ITEM -1
    int key;
    int i;
    int NumberItemDelete;
    void *Dest_str; //куда копируем
    void * Source_str;//откуда копируем
    int SizeCopy ;//количество копируемых байт
    int del_offset;
    //////////////////////////////////////////////////////////////////////////
    puts("введите ключ");
    while (!scanf("%i", &key))
    {
        scanf( "%*[^\n]" ); scanf( "%*c" );// не много магии
        puts("не корректный ввод, повторите операцию");
    }
    //////////////////////////////////////////////////////////////////////////
    while(!CheckKey(key))
    {
        puts("такой ключ не существует, 1 - для ввода нового ключа, любой другой символ для выхода ");
        if(!scanf("%i",&key))
            return;
        if(key == REENTERED)
        {
            puts("введите ключ");
            while (!scanf("%i", &key))
            {
                scanf( "%*[^\n]" ); scanf( "%*c" );// не много магии
                puts("не корректный ввод, повторите операцию");
            }   
        }
        else
        {
            return;
        }
    }
    //////////////////////////////////////////////////////////////////////////
    NumberItemDelete = FindOneKey(key);//порядковый номер
    if(NumberItemDelete > NO_ITEM)
    {
        del_offset = sizeof(int) * 3 + Items[NumberItemDelete].length;;
        if(NumberItemDelete != ItemSize)
        {
            free(Items[NumberItemDelete].info);//для последнего элемента память не уудаляется - костыль!!!!!!!!!!!!!!!
            Dest_str = &Items[0] +  NumberItemDelete;
            Source_str = &Items[0] + NumberItemDelete+1; 
            SizeCopy = sizeof(struct Item) * (ItemSize - NumberItemDelete - 1);
            memcpy(Dest_str,Source_str,SizeCopy);//сдвигаем массив , альтернативой может быть запись последнего элемента на место удаляемого
        }
    }
    
    for(i = NumberItemDelete; i < ItemSize;i++)
    {
        Items[i].offset -= del_offset;
    }
    ItemSize--;//уменьшаем размер списка
    //Save(g_nameFileOpen);
 
}
//////////////////////////////////////////////////////////////////////////
 
void PrintItems(struct Item *item_, int size)//печать списка
{
    int i;
    for(i = 0; i < size; i++)
    {
        printf("элемент с ключом %i и смещением %i --- %s \r\n", item_[i].key,item_[i].offset, item_[i].info);
    }
}
//////////////////////////////////////////////////////////////////////////
 
int CountIndexKey (int lower_key,int top_key)//определяет количество элементов с подходящим ключом
{
    int i;
    int answer = 0;
    for(i = 0; i < ItemSize; i++)
    {
        if(Items[i].key <= top_key && Items[i].key >= lower_key)
            answer++;// акамулятор
    }
    return answer;
}
//////////////////////////////////////////////////////////////////////////
 
struct Item *FindItems(int *SizeMoreItems)
{
    struct Item *NewItems;// новый списко/массив
    int lower_key, top_key;
    int TempSize = 0; //порядковый номер в новом списке
    int i; //порядковый номер в основном списке
    void *Dest_str; //куда копируем
    void * Source_str;//откуда копируем
    int SizeCopy ;//количество копируемых байт
    //////////////////////////////////////////////////////////////////////////
    puts("введите нижнюю границу ключа");
    while (!scanf("%i", &lower_key))
    {
        scanf( "%*[^\n]" ); scanf( "%*c" );// не много магии
        puts("не корректный ввод, повторите операцию");
    }
    puts("введите верхнюю границу ключа");
    while (!scanf("%i", &top_key))
    {
        scanf( "%*[^\n]" ); scanf( "%*c" );// не много магии
        puts("не корректный ввод, повторите операцию");
    }
    //////////////////////////////////////////////////////////////////////////
    *SizeMoreItems = CountIndexKey(lower_key,top_key);
    NewItems = (struct Item*)malloc(sizeof(struct Item) * *SizeMoreItems);
    for(i = 0; i < ItemSize; i++)
    {
            if(Items[i].key <= top_key && Items[i].key >= lower_key)
            {
                Dest_str = &NewItems[0] +  TempSize; 
                Source_str = &Items[0] + i;
                SizeCopy = sizeof(struct Item);
                memcpy(Dest_str,Source_str,SizeCopy);
                TempSize++;
            }
    }
    //////////////////////////////////////////////////////////////////////////
    return NewItems;
 
}
//////////////////////////////////////////////////////////////////////////
 
int main()
{
    
    
    
    int answer = ANSWER_EMPTY;
    struct Item *MoreItems = 0;
    int SizeMoreItems;
    //////////////////////////////////////////////////////////////////////////
    setlocale(LC_ALL,"Russian");
    g_nameFileOpen = (char*)malloc(sizeof(char) * ( MaxFileName + 1) ); // временный буфер для считывания
    do
    {
        puts("Введите имя файла для считывания данных(можно вводить локальное имя/путь)");
        //gets(g_nameFileOpen);
        strcpy(g_nameFileOpen,"data.bin");
    }while(!init(g_nameFileOpen));
    
    //////////////////////////////////////////////////////////////////////////
    while (answer)
    {
        puts("выберите команду");
        puts("0 - выход");
        puts("1 - добавить элемент");
        puts("2 - удалить элемент");
        puts("3 - напечатать элементы");
        puts("4 - поиск элементов");
        puts("5 - напечатать дополнительный список");
        if (!scanf("%i", &answer))
        {
            scanf( "%*[^\n]" ); scanf( "%*c" );// не много магии
            puts("не корректный ввод, повторите операцию");
            answer = 5;
            continue;
        }
        switch(answer)
        {
            case 1:
                AddItem();
                break;
            case 2:
                DeleteItem();
                break;
            case 3:
                PrintItems(Items,ItemSize);
                break;
            case 4:
                MoreItems = FindItems(&SizeMoreItems);
                break;
            case 5:
                PrintItems(MoreItems,SizeMoreItems);
                break;
        }
    }
    //////////////////////////////////////////////////////////////////////////
    Save(g_nameFileOpen);
    free(buf);
    free(g_nameFileOpen);
    return 0;
}

 if(NumberItemDelete != ItemSize)