进程在Malloc或文件上以返回值32225477退出

那里。^^ 我一直在做一个小项目来帮助我做一些简单的事情，在家里练习，当我开始对malloc施加影响时。我从这段代码开始，完成，尝试运行它，但它不打印任何内容，并给出以下退出：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<time.h>    
#define imprime toString
#define erro printf("\n\nCaractere invalido! Digite novamente!\n\n")

//Programa de administração de Conta por mês
//Configurações: Full Manuel, contas simples, armazenamento em arquivo, criação de usuário simples

typedef struct
{
    char* texto;
}String;

typedef struct 
{
    String nome[100];
    float preco;
    time_t data;
}Conteudo;

struct celula
{
    Conteudo compra;
    struct celula* prox;
};

typedef struct celula Celula; 

//Operacoes com lista Ligada

Celula* criaLista()
{
    Celula* nova = malloc(sizeof(Celula));
    return nova;
}

    int checaTamanhoLista(Celula* cabecaLista)
    {
        int cont=0;
        Celula* teste;
        for(teste = cabecaLista; teste->prox != NULL; teste = teste->prox)
    {
        cont++;
    }return cont;
}

Celula* retornaFim(Celula* cabecaLista)
{
    Celula* verif = cabecaLista;
    while(verif->prox != NULL)
    {
        verif = verif->prox;
    }return verif;
}

Celula* buscaCelulaAnt(Celula* cabecaLista, String* nome)
{
    Celula* verif = cabecaLista;
    while(verif->prox!=NULL)
    {
        if(strcmp(verif->prox->compra.nome->texto, nome->texto)==0)
        {
            return verif;
        }
        verif = verif->prox;
    }return NULL;
}

Celula* buscaCelula(Celula* cabecaLista, String* nome)
{
    Celula* verif = cabecaLista;
    while(verif->prox!=NULL)
    {
        if(strcmp(verif->prox->compra.nome->texto, nome->texto)==0)
        {
            return verif->prox;
        }
        verif = verif->prox;
    }return NULL;
}

void adicionaCelula(Celula* cabecaLista, Celula* c)
{
    retornaFim(cabecaLista)->prox = c;
    c->prox = NULL;
}

void adicionaCelulaMeio(Celula* cabecaLista, Celula* c, String* nome)
{
    Celula* teste = buscaCelula(cabecaLista, nome);
    c->prox = teste->prox;
    teste->prox = c;
}

void removeCelula(Celula* cabecaLista, String* nome)
{
    Celula* teste = buscaCelulaAnt(cabecaLista, nome);
    Celula* limpar = teste->prox;
    teste->prox = teste->prox->prox;
    free(limpar);
}

//Operacoes de Elemento

Celula* criaCelula(String* nome, float preco, time_t data)
{
    Celula* nova = malloc(sizeof(Celula));
    fflush(stdin);
    sprintf(nova->compra.nome->texto, "%s ", nome->texto);
    nova->compra.preco = preco;
    nova->compra.data = data;
    return nova;
}

char* toStringLista(Celula* cabecaLista)
{
    Celula* teste;
    char* nome;
    char* temp;
    for(teste = cabecaLista; teste->prox!= NULL; teste = teste->prox)
    {
        fflush(stdin);
        sprintf(temp, "%s   - %.2f  - %s\n", teste->compra.nome, teste->compra.preco, ctime(&teste->compra.data));
        strcat(nome, temp);
        fflush(stdin);
        sprintf(temp, "");
    }return nome;
}

char* toStringCelula(Celula* cabecaLista, String* nome)
{
    Celula* temp = buscaCelula(cabecaLista, nome);
    char* string;
    fflush(stdin);
    sprintf(string, "%s     - %.2f  - %s\n", temp->compra.nome, temp->compra.preco, ctime(&temp->compra.data));
    return string;
}

void corrigirPreco(Celula* c, float preco)
{
    c->compra.preco = preco;
}

void corrigirNome(Celula* c, char* nome)
{
    fflush(stdin);
    strcpy(c->compra.nome->texto, nome);
}

//Operações de Arquivo

void tornarDat(String* nome)
{
    fflush(stdin);
    strcat(nome->texto, ".dat");
}

void criarArquivo(char* nome)
{
    FILE* arq = fopen(nome, "w");
    fclose(arq);
}

void lerArquivo(Celula* cabecaLista, String* nomeLista, String* nomeTam, String* nomeOrc, float* orcamento, int* tamanhoLista)
{
    FILE* arqTam = fopen(nomeTam->texto, "rb");
    fread(tamanhoLista, sizeof(int), 1, arqTam);
    fclose(arqTam);

    FILE* arqOrc = fopen(nomeOrc->texto, "rb");
    fread(orcamento, sizeof(float), 1, arqOrc);
    fclose(arqOrc);

    Conteudo v[*tamanhoLista];

    FILE* arqLista = fopen(nomeLista->texto, "rb");
    fread(v, sizeof(Conteudo), *tamanhoLista, arqLista);
    int i;
    for(i=0; i<*tamanhoLista; i++)
    {
        adicionaCelula(cabecaLista, criaCelula(v[i].nome, v[i].preco, v[i].data));
    }
    fclose(arqLista);
}

void salvarArquivos(Celula* cabecaLista, String* nomeTam, String* nomeLista, String* nomeOrc, float* orc)
{
    int i;
    int* tam = malloc(sizeof(int));
    *tam = checaTamanhoLista(cabecaLista);
    Conteudo v[*tam-1];
    for(i=0; i<*tam-1; i++)
    {
        if(cabecaLista->prox!=NULL)
        v[i] = cabecaLista->prox->compra;
    }

    FILE* arqOrc = fopen(nomeOrc->texto, "w");
    fwrite(orc, sizeof(float), 1, arqOrc);
    fclose(arqOrc);

    FILE* arqTam = fopen(nomeTam->texto, "w");
    fwrite(tam, sizeof(int), 1, arqTam);
    fclose(arqTam);

    FILE* arqList = fopen(nomeLista->texto, "w");
    fwrite(v, sizeof(Conteudo), *tam-1, arqList);
    fclose(arqList);

    free(tam);
}

//Execuções de sistema

void limpaRam(Celula* cabecaLista)
{
    Celula* teste;
    for(teste = cabecaLista; teste!=NULL; teste = teste->prox)
    {
        free(teste);
    }
}

void atualizaOrcamento(Celula* c, float* orcamento, int x)
{
    if(x==0)
    {
        *orcamento -= c->compra.preco;  
    }else if(x==1)
    {
        *orcamento += c->compra.preco;
    }
}    

void startDatabase(String* nomeLista, String* nomeTam, String* nomeOrc)
{
    FILE* arqList, *arqTam, *arqOrc;
    arqList = fopen(nomeLista->texto, "rb");
    if(arqList == NULL)
    {
        arqList = fopen(nomeLista->texto, "w");
    }
    arqTam = fopen(nomeTam->texto, "rb");
    if(arqTam == NULL)
    {
        arqTam = fopen(nomeTam->texto, "w");
    }
    arqOrc = fopen(nomeOrc->texto, "rb");
    if(arqOrc == NULL)
    {
        arqOrc = fopen(nomeOrc->texto, "w");
    }
    fclose(arqList);
    fclose(arqTam);
    fclose(arqOrc);
}

void startAll(Celula* lista, String* nomeArquivoLista, String* nomeArquivoTam, String* nomeArquivoOrc)
{
    startDatabase(nomeArquivoLista, nomeArquivoTam, nomeArquivoOrc);
    lerArquivo(lista, nomeArquivoLista, nomeArquivoTam, nomeArquivoOrc, orc, tamLista);
}
//Funcoes menu

void adicionaCompra(Celula* cabecaLista, String* nomeDaCompra, float* preco, time_t data, String* arquivoLista, String* arquivoTam, String* arqOrc, float* orc)
{
    adicionaCelula(cabecaLista, criaCelula(nomeDaCompra, *preco, data));
    atualizaOrcamento(buscaCelula(cabecaLista, nomeDaCompra), orc, 0);
    salvarArquivos(cabecaLista, arquivoTam, arquivoLista, arqOrc, orc);
}

void removeCompra(Celula* cabecaLista, String* nomeDaCompra, String* arquivoLista, String* arquivoTam, String* arqOrc, float* orc)
{
    atualizaOrcamento(buscaCelula(cabecaLista, nomeDaCompra), orc, 1);
    removeCelula(cabecaLista, nomeDaCompra);
    salvarArquivos(cabecaLista, arquivoTam, arquivoLista, arqOrc, orc);
}

void menu(char* resp)
{
    printf("Responda com a primeira letra da Função:\n  ->Adicionar Compra\n    ->RemoverCompra\n   ->Sair\n\n              =>");
    scanf("%c", resp);
}

void menuAdiciona(String* nomeVariante, float* precoVariante)
{
    fflush(stdin);
    printf("Diga o que voce comprou: ");
    gets(nomeVariante->texto);
    printf("\nDiga o preco: ");
    scanf("%f", precoVariante);
    getchar();
}

void menuRemove(String* nomeVariante)
{
    fflush(stdin);
    printf("Digite o nome da compra a remover (exit para sair): ");
    gets(nomeVariante->texto);
}

//Main

void main()
{
    //Declarações

        String* nomeDoArquivoLista = malloc(sizeof(String));
        String* nomeDoArquivoTamanho = malloc(sizeof(String));
        String* nomeDoArquivoOrcamento = malloc(sizeof(String));
        String* nomeVariante = malloc(sizeof(String));
        int* tamanhoLista = malloc(sizeof(int));
        float* precoVariante = malloc(sizeof(float));
        float* orcamento = malloc(sizeof(float));
        char* resp = malloc(sizeof(char));
        Celula* listaComCabeca = malloc(sizeof(Celula));
        *orcamento = 600;
    //Atribuições Padrão

        sprintf(nomeDoArquivoLista->texto, "lista");
        tornarDat(nomeDoArquivoLista);
        sprintf(nomeDoArquivoTamanho->texto, "tam");
        tornarDat(nomeDoArquivoTamanho);
        sprintf(nomeDoArquivoOrcamento->texto, "orcamento");
        tornarDat(nomeDoArquivoOrcamento);
        startDatabase(nomeDoArquivoLista, nomeDoArquivoTamanho, nomeDoArquivoOrcamento);
        lerArquivo(listaComCabeca, nomeDoArquivoLista, nomeDoArquivoTamanho, nomeDoArquivoOrcamento, orcamento, tamanhoLista);

    //Execuções

        do
        {
            system("cls");
            menu(resp);
            *resp = toupper(*resp);
            switch(*resp)
            {
                case 'A':
                    menuAdiciona(nomeVariante, precoVariante);
                    adicionaCompra(listaComCabeca, nomeVariante, precoVariante, time(NULL), nomeDoArquivoLista, nomeDoArquivoTamanho, nomeDoArquivoOrcamento, orcamento);
                    break;
                case 'R':
                    menuRemove(nomeVariante);
                    removeCompra(listaComCabeca, nomeVariante, nomeDoArquivoLista, nomeDoArquivoTamanho, nomeDoArquivoOrcamento, orcamento);
                    break;
                case 'S':
                    salvarArquivos(listaComCabeca, nomeDoArquivoTamanho, nomeDoArquivoLista, nomeDoArquivoOrcamento, orcamento);
                    break;
                default:
                    erro;
                    salvarArquivos(listaComCabeca, nomeDoArquivoTamanho, nomeDoArquivoLista, nomeDoArquivoOrcamento, orcamento);
                    break;
            }
        }while(*resp!='S');

    //Fim
        free(resp);
        free(orcamento);

        free(nomeVariante);
        free(precoVariante);

        limpaRam(listaComCabeca);
        free(tamanhoLista);
        free(nomeDoArquivoLista);
        free(nomeDoArquivoTamanho);
        free(nomeDoArquivoOrcamento);
}

#包括
#包括
#包括
#包括
#包括
#定义imprime toString
#定义erro printf（“\n\n合同无效！数字更新！\n\n”）
//港口管理方案
//配置：完整的曼努埃尔、简单的康塔斯、Armazenameto em arquivo、简单的克里亚诺
类型定义结构
{
char*texto；
}弦；
类型定义结构
{
字符串名称[100]；
浮子预滤器；
时间数据；
}孔杜多；
细胞结构
{
孔杜康帕；
结构celula*prox；
};
细胞结构类型；
//利加达歌剧院
Celula*criaLista（）
{
Celula*nova=malloc（sizeof（Celula））；
返回新星；
}
切卡塔曼霍利斯塔国际酒店（Celula*cabecaLista）
{
int cont=0；
睾丸；
for（teste=cabecaLista；teste->prox！=NULL；teste=teste->prox）
{
cont++；
}返回控制；
}
Celula*Retronafim（Celula*cabecaLista）
{
Celula*verif=cabecaLista；
while（verif->prox！=NULL）
{
verif=verif->prox；
}返回verif；
}
Celula*buscaCelulaAnt（Celula*cabecaLista，字符串*nome）
{
Celula*verif=cabecaLista；
while（verif->prox！=NULL）
{
如果（strcmp（verif->prox->compra.nome->texto，nome->texto）==0）
{
返回verif；
}
verif=verif->prox；
}返回NULL；
}
Celula*buscaCelula（Celula*cabecaLista，字符串*nome）
{
Celula*verif=cabecaLista；
while（verif->prox！=NULL）
{
如果（strcmp（verif->prox->compra.nome->texto，nome->texto）==0）
{
返回verif->prox；
}
verif=verif->prox；
}返回NULL；
}
无效Adicionacella（Celula*cabecaLista，Celula*c）
{
Retronafim（cabecaLista）->prox=c；
c->prox=NULL；
}
无效adicionaCelulaMeio（Celula*cabecaLista、Celula*c、String*nome）
{
Celula*teste=buscaCelula（cabecaLista，nome）；
c->prox=teste->prox；
teste->prox=c；
}
void removeclula（Celula*cabecaLista，String*nome）
{
Celula*teste=buscaCelulaAnt（cabecaLista，nome）；
Celula*limpar=teste->prox；
teste->prox=teste->prox->prox；
自由（林巴）；
}
//元素歌剧院
Celula*criaCelula（字符串*nome、浮点预编码、时间数据）
{
Celula*nova=malloc（sizeof（Celula））；
fflush（stdin）；
sprintf（新星->压缩命名->文本，“%s”，命名->文本）；
nova->compra.preco=preco；
新星->压缩数据=数据；
返回新星；
}
char*toStringLista（Celula*cabecaLista）
{
睾丸；
char*nome；
字符*温度；
for（teste=cabecaLista；teste->prox！=NULL；teste=teste->prox）
{
fflush（stdin）；
sprintf（temp，“%s-%.2f-%s\n”，teste->compra.nome，teste->compra.preco，ctime（&teste->compra.data））；
strcat（nome，temp）；
fflush（stdin）；
sprintf（temp，“”）；
}返回nome；
}
char*toStringCelula（Celula*cabecaLista，String*nome）
{
Celula*温度=buscaCelula（cabecaLista，nome）；
字符*字符串；
fflush（stdin）；
sprintf（字符串，“%s-%.2f-%s\n”，temp->compra.nome，temp->compra.preco，ctime（&temp->compra.data））；
返回字符串；
}
空隙预滤器（Celula*c，浮子预滤器）
{
c->compra.preco=preco；
}
无效corrigirNome（Celula*c，char*nome）
{
fflush（stdin）；
strcpy（c->compra.nome->texto，nome）；
}
//阿尔基沃歌剧院
void tornarDat（字符串*nome）
{
fflush（stdin）；
strcat（nome->texto，“.dat”）；
}
无效克里亚拉基沃（char*nome）
{
文件*arq=fopen（nome，“w”）；
fclose（arq）；
}
void lerArquivo（Celula*cabecaLista，String*nomeLista，String*nomeTam，String*nomeOrc，float*orcamento，int*tamanhoLista）
{
文件*arqTam=fopen（nomeTam->texto，“rb”）；
fread（塔曼霍利斯塔，sizeof（int），1，arqTam）；
fclose（arqTam）；
文件*arqOrc=fopen（nomeOrc->texto，“rb”）；
fread（奥卡门托，sizeof（浮动），1，arqOrc）；
fclose（arqOrc）；
孔杜多五世[*塔曼霍利斯塔]；
文件*arqLista=fopen（nomeLista->texto，“rb”）；
fread（v，sizeof（Conteudo），*塔曼霍利斯塔，阿奎利斯塔）；
int i；
对于（i=0；iprox->compra；
}
文件*arqOrc=fopen（nomeOrc->texto，“w”）；
fwrite（orc、sizeof（float）、1、arqOrc）；
fclose（arqOrc）；
文件*arqTam=fopen（nomeTam->texto，“w”）；
fwrite（tam，sizeof（int），1，arqTam）；
fclose（arqTam）；
文件*arqList=fopen（nomeLista->texto，“w”）；
fwrite（v，sizeof（Conteudo），*tam-1，arqList）；
fclose（arqList）；
免费（tam）；
}
//系统执行委员会
void limpaRam（Celula*cabecaLista）
{
睾丸；
for（teste=cabecaLista；teste！=NULL；teste=teste->prox）
{
自由（睾丸）；
}
}
无效阿塔利亚扎尔卡门托（塞卢拉*c，浮动*奥卡门托，整数x）
{
如果（x==0）
{
*orcamento-=c->compra.preco；
}else如果（x==1）
{
*orcamento+=c->compra.preco；
}
}    
void startDatabase（String*nomeLista，String*nomeTam，String*nomeOrc）
{
文件*arqList、*arqTam、*arqOrc；
arqList=fopen（nomeLista->texto，“rb”）；
if（arqList==NULL）
{
arqList=fopen（nomeLista->texto，“w”）；
}
arqTam=fopen（nomeTam->texto，“rb”）；
if（arqTam==NULL）
{
arqTam=fopen（nomeTam->texto，“w”）；
}
arqOrc=fopen（nomeOrc->texto，“rb”）；
if（arqOrc==NULL）
{
arqOrc=fopen（nomeOrc->texto，“w”）；
}
fclose（arqList）；
fclose（arqTam）；
fclose（arqOrc）；
}
void startAll（Celula*lista，String*nomerquivolista，String*nomerquivotam，String*nomerquivoorc）
{
startDatabase（nomeArquivoLista、nomeArquivoTam、nomeArquivoOrc）；
lerArquivo（lista、nomeArquivoLista、nomeArquivoTam、nomeArquivoOrc、orc、tamLista）；
}
//功能菜单
void adicionaCompra（Celula*cabecaLista，String*nomeDaCompra，float*preco，time\u t data，String*arquivoLista，String*arquivoTam，String*