C Alocação e realocação de vetor de estruturas

Lucas_Vinicius_147 · 28 de fevereiro de 2020

Boa tarde, sou iniciante em programação em C e estou tentando criar um programa que registre produtos de um supermercado e suas informações como unidades diponíveis, nome, preço de compra e venda etc.. No entanto, a quantidade de produtos a serem cadastrados é desconhecida, preciso que o usuário possa, por exemplo, regitrar x produtos numa execução, voltar ao menu e depois registrar mais y produtos. Preciso fazer isso usando malloc e realloc, mas estou tendo alguns problemas e dúvidas.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
  
struct n_produto
{
    char nome[150];
    float valorV;
    float valorC;
    int unidades;
};
void menu();
void new_p(struct n_produto *newp, int *qt);

    int main()
    {
    setlocale(LC_ALL,"");
    // Variáveis
    int op,qtp=1;
    struct n_produto *newp;

    newp = malloc(qtp*sizeof(struct n_produto));
    if(newp==NULL)
    {
        printf("erro ao alocar");
        exit(1);
    }

    while(op>=0)
    {
        menu();
        printf("\n\n\n\tDigite o número correspondente\n\ta opção desejada: ");
        scanf("%d",&op);
        system("cls");
        printf("\n");
        switch(op)
        {
        case 1:
            new_p(newp,&qtp);
            break;
        }


    }

        return 0;
    }

void menu()
{
   printf("\t=====PAINEL DE CONTROLE DO SUPERMERCADO=====\n\n");
   printf("\n\t[1] Adicionar produtos ao estoque.\n\n");
}

void new_p(struct n_produto *newp, int *qt)
{
    if(*qt > 1) newp += *qt;
    printf("\tNome do produto: ");
    fflush(stdin);
    fgets(newp->nome,150,stdin);
    printf("\tUnidades: ");
    scanf("%d",&newp->unidades);
    printf("\tPreço de venda: ");
    scanf("%f",&newp->valorV);
    printf("\tPreço de compra: ");
    scanf("%f",&newp->valorC);
    system("cls");
    *qt = *qt + 1; // Aumenta o valor que representa quantidades de produtos
    newp = realloc(newp,*qt*sizeof(struct n_produto)); // Realoca o vetor com uma posição a mais para um próximo produto
   	if(newp==NULL)
    {
  	printf("erro ao realocar");
    exit(1);
   	}
}

A alocação e realocação estão corretas? Nas execuções que fiz em nenhum momento o erro de ponteiro NULL foi exibido, mas ainda assim o programa para quando tento ler valores nas posições supostamente realocadas.
Esse método newp += *qt serve para pular a posição do ponteiro ou está errado?

Agradeço a quem puder ajudar, estou a dias tentando dar continuidade a esse programa mas fiquei travado nessa parte.

arfneto · 29 de fevereiro de 2020

4 horas atrás, Lucas_Vinicius_147 disse:

preciso que o usuário possa, por exemplo, regitrar x produtos numa execução, voltar ao menu e depois registrar mais y produtos. Preciso fazer isso usando malloc e realloc, mas

Está mais ou menos correto. realloc() vai de fato realocar memória a partir de um bloco previamente alocado por malloc() mas isso implica em potencialmente copiar tudo para outra área de memória com o novo tamanho.

Ao usar isso a cada execução você fica copiando tudo a cada vez de novo para aumentar só um. é uma coisa estranha e não se usa isso. Em geral nem se usa realloc() mas quando se usa o normal é usar uma unidade, um bloco de produtos. Por exemplo comece com 10 produtos e depois vá dobrando a cada necessidade: 10/20/40/80...

Em geral se usa uma estrutura de dados chamada lista ou algo parecido, ou um vetor de ponteiros. Pergunte de novo se não sabe do que estou falando.

De volta ao seu programa

O que você queria de fato acho que era alocar um vetor de produtos, e endereçar de acordo, algo como

	struct produto Produtos[500];
	Produtos[300].unidades = 125;
	Produtos[125].valorC = 123.23;
	strcpy(Produtos[80].nome, "um produto");
	printf("unidades do %d: %d\n", 300, Produtos[300].unidades);
	printf("valorC do %d: %6.2f\n", 125, Produtos[125].valorC);
	printf("nome do %d: [%s]\n", 80, Produtos[80].nome);

E ver

unidades do 300: 125
valorC do 125: 123.23
nome do 80: [um produto]

Mas não dá, porque você vai alocar isso em tempo de execução...

Como declarar isso então para ter um resultado parecido?

Você declarou assim

struct n_produto *newp; newp = malloc(qtp*sizeof(struct n_produto));

Podia ter escrito um comando só

struct n_produto *newp = (struct n_produto*) malloc( qtp * sizeof(struct n_produto) );

É mais comum: malloc(0 retorna um pointer para void, um genérico. E você deve usar algo tipo (int*) para indicar ao compilador que quer converter o ponteiro para um ponteiro para o tipo certo. Se chama cast

Mas no seu caso está errado: assim vai alocar uma área para qtp desses produtos, mas não adianta nada: newp vai continuar sendo um ponteiro para um único produto... E assim não vai conseguir acessar os outros.

Há muitas maneiras de fazer isso. Uma simples seria simplesmente criar um outro ponteiro e ir deslocando em unidades de sizeof(struct n_produto). No entanto isso é o que o compilador faria por si só então deve ter um jeito de declarar isso...

Se

struct produto Produtos[500];

permite acessar um a um, então um ponteiro para isso seria declarado e usado assim:

    struct produto (*produtos)[1]; // ponteiro para um vetor de 1 so. Tanto faz
    produtos = (struct produto*) realloc(produtos, (sizeof(struct produto) * BLOCO )); // aloca um BLOCO deles
    (*produtos)[55].unidades = 234; // acessa um produto. Seu problema se forem menos de 56 :)

Use assim. E não deixe de usar free() ao final para liberar a área.

O Exemplo a seguir mostra

unidades do 300: 125
valorC do 125: 123.23
nome do 80: [um produto]

unidades do ultimo produto de 10: 9
produto[ 0]: 0
produto[ 1]: 1
produto[ 2]: 2
produto[ 3]: 3
produto[ 4]: 4
produto[ 5]: 5
produto[ 6]: 6
produto[ 7]: 7
produto[ 8]: 8
produto[ 9]: 9
produto[10]: 10
produto[11]: 11
produto[12]: 12
produto[13]: 13
produto[14]: 14
produto[15]: 15
produto[16]: 16
produto[17]: 17
produto[18]: 18
produto[19]: 19

Eis o programa. Rode em sua máquina

#define _CRT_SECURE_NO_WARNINGS
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

struct produto
{	char nome[50];
	float valorC;
	int unidades;
};

int main(int argc, char** argv)
{
	struct produto Produtos[500];
	Produtos[300].unidades = 125;
	Produtos[125].valorC = 123.23f;
	strcpy(Produtos[80].nome, "um produto");
	printf("unidades do %d: %d\n", 300, Produtos[300].unidades);
	printf("valorC do %d: %6.2f\n", 125, Produtos[125].valorC);
	printf("nome do %d: [%s]\n", 80, Produtos[80].nome);

	struct produto (*produtos)[1];

	produtos = malloc( sizeof(struct produto)* 10);
	
	for (int i = 0; i < 10; i += 1)
		(*produtos)[i].unidades = i;

	printf("\nunidades do ultimo produto de 10: %d\n", (*produtos)[9].unidades);

	produtos = realloc(produtos, (sizeof(struct produto) * 500));
	
	for (int i = 10; i < 20; i += 1)
		(*produtos)[i].unidades = i;

	for (int i = 0; i < 20; i += 1)
		printf("produto[%2d]: %d\n", i, (*produtos)[i].unidades);

	free(produtos);
};	// end main()