Процесс завершен с возвращаемым значением 3221225477 в Malloc или File - PullRequest
Новая
       2

Процесс завершен с возвращаемым значением 3221225477 в Malloc или File

0 голосов
/ 14 сентября 2018

есть. ^^ Я делал небольшой проект, чтобы помочь мне с простыми вещами, тренируясь дома, когда я начал рассказывать о 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);
}

Кроме этого, код отлично работает. Код - это попытка организовать деньги в месяц, он создает связанный список и добавляет к нему расходы. Я дважды проверил все отсутствующие free () для каждого malloc, и все же это приводит к той же проблеме.

1 Ответ

0 голосов
/ 14 сентября 2018

Вы разыменовываете неинициализированную память, что приводит к сбою.

String* nomeDoArquivoLista = malloc(sizeof(String)); выделяет некоторую память для объекта String, но эта память неинициализирована, так что nomeDoArquivoLista->texto может иметь любое значение.Позже, когда вы вызываете sprintf(nomeDoArquivoLista->texto, "lista");, вы передаете это неинициализированное значение библиотечной функции, которая попытается записать в нее.Поскольку указатель, который он получает, вероятно, недействителен, это приводит к сбою.

После выделения памяти для ваших String объектов вы захотите выделить некоторое пространство для texto, на которое можно указать.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.

Нет похожих вопросов

...