C Estou com problema com FOR.

Mateus Elias · 20 de setembro de 2019

/*

DÚVIDA:

QUANDO PEÇO PARA O USUÁRIO DIGITAR A QUANTIDADE DE CADASTROS A SER FEITO, ACONTECE ALGO ESTRANHO.

EX; Se desejo fazer dois cadastros ele intende 3 cadastros e depois imprime apenas os dois últimos.

Ja olhei os indices e todos iniciam em zero, se alguém puder me ajudar..agradeço.

*/

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

struct mercado{
char nome[30];
char marca[30];
float valor;
int estoque;
};
typedef struct mercado mercado;

void Leproduto(mercado *v)
{
printf("Nome do Produto: ");
fflush(stdin);
scanf("%[^\n]s",&(*v).nome);
printf("Marca do Produto: ");
fflush(stdin);
scanf("%[^\n]s",&(*v).marca);
printf("Valor do Produto: ");
scanf("%f",&(*v).valor);
printf("Quantidade em Estoque: ");
scanf("%d",&(*v).estoque);

system("cls");
}
void Leprodutos(mercado *v, int n)
{
int i;
for(i=0;i<n;i++)
{
Leproduto(&v);

}

}
void imprime(mercado v)
{

   printf("Nome: %s\n",v.nome);
   printf("Marca: %s\n",v.marca);
   printf("Valor: %.2f\n",v.valor);
   printf("Estoque: %d\n",v.estoque);

}
int main()
{
setlocale(LC_ALL,"Portuguese");

mercado *P;

int quant,i;

printf("Quantidade de cadastros: ");
scanf("%d",&quant);
//system("cls");

P=(mercado*)malloc(quant*sizeof(mercado));
if(P==NULL)
{
printf("Alocação indisponível\n");
return 1;
}

puts("");

Leproduto(P);
Leprodutos(P,quant);

for(i=0;i<quant;i++)
{
imprime(P);
}

return 0;
}

KXSY · 20 de setembro de 2019

Vamos lá, primeiro de tudo sugiro você pensar no algorítimo antes de começar a escrever (papel e lápis ajudam nessa parte).

39 minutos atrás, Mateus Elias disse:

fflush(stdin);

Isso e uma gambiarra, programação em si já e uma grande gambiarra então evite gambiarras externas, como o uso do sistem

40 minutos atrás, Mateus Elias disse:

system("cls");

isso só funciona em DOS-like qualquer outro sistema vai ou dar erro ou não vai fazer nada

42 minutos atrás, Mateus Elias disse:

scanf("%[^\n]s",&(*v).nome);

não é preciso passa o endereço de um vetor, exemplo a variável nome e um vetor que passado assim *v.nome já vai passa o endereço da variável.

seu código funcionando, não perfeitamente mas sim funcionado

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

struct mercado{
    char nome[30];
    char marca[30];
    float valor;
    int estoque;
};
typedef struct mercado mercado;


void Leproduto(mercado *v)
{
        printf("Nome do Produto: ");
        fgets(v->nome,10,stdin);
        printf("Marca do Produto: ");
        fgets(v->marca,10,stdin);
        printf("Valor do Produto: ");
        scanf("%f",&v->valor);
        getchar();
        printf("Quantidade em Estoque: ");
        scanf("%d",&v->estoque);
        getchar();

        /*system("cls"); */
}
void Leprodutos(mercado *v, int n)
{
    int i;
    for(i=0;i<n;i++)
    {
        Leproduto(&v[i]);

    }

}
void imprime(mercado *v)
{
    
    printf("Nome: %s\n",v->nome);
    printf("Marca: %s\n",v->marca);
    printf("Valor: %.2f\n",v->valor);
    printf("Estoque: %d\n",v->estoque);
    
}
int main()
{
    setlocale(LC_ALL,"Portuguese");

    mercado *P;
    
    int quant,i;

    printf("Quantidade de cadastros: ");
    scanf("%d",&quant);
    getchar();
    //system("cls");
    
    
    P=malloc(quant*sizeof(mercado));
    if(P==NULL)
    {
        printf("Alocação indisponível\n");
        return 1;
    }

    puts("");

   Leproduto(P);
   Leprodutos(P,quant);
   
   for(i=0;i<quant;i++)
   {
       imprime(P);
   }
   

return 0;
}

Tem muita coisa para explicar ai, mas deixo pra uma próxima vez (como o operador ponto(.) e o seta (->))

outra coisa que eu recomendo fortemente e usar o GCC sem IDE, porque algumas IDEs omitem alguns erros e forçam a compilação do código, se você e iniciante erro e o que você vai mais querer ver na sua vida.

arfneto · 21 de setembro de 2019

Olá

Seu programa está quase certo, mas está confundindo talvez esses operadores de endereço, * & -> e tal. Talvez não tenha sido explicado muito sobre o modo como C endereça memória e o que se convenciona chamar de aritmética de ponteiros, que é provavelmente o recurso mais importante dessa linguagem e a razão para se escrever sistemas e programar chips com programas em C.

Considere

struct Mercado
{
    char nome[30];
    char marca[30];
    float valor;
    int estoque;
};

typedef struct Mercado mercado;

mercado 	um;
mercado* 	P;
mercado 	trezentos_mercados[300];

Isso declara uma estrutura do tipo mercado em um, mais um vetor com 300 mercado em m. E P é uma variável que pode conter um endereço de uma coisa dessas, mercado.

E como endereçar essas coisas? No caso do vetor, tem duas maneiras de você acessar. trezentos_mercados é um ponteiro para mercado, assim como P. É muito importante entender isso: trezentos_mercados e P são ponteiros para mercado. Só que trezentos_mercados é constante e P não.

Então eu posso escrever por exemplo

    quant = 1;
    t = quant * sizeof(mercado);
    printf("Alocados %d bytes para %d estruturas \"mercado\" de %d bytes\n",
        t, quant, sizeof(mercado));

    P = trezentos_mercados;
    P = &um;
    P = (mercado*)malloc(t);

E ver isso na tela

Alocados 68 bytes para 1 estruturas "mercado" de 68 bytes
Alocados 68 bytes

O operador & extrai o endereço de um, que é do tipo mercado. E P é do mesmo tipo, então está correto escrever P = &um. trezentos_mercados foi declarado como vetor de 300 mercado e então a variável em si contem o endereço da primeira ocorrência de trezentos_mercados, trezentos_mercados[0]. E então está certo escrever P = trezentos_mercados.

mercado* coisa;

declara coisa como um ponteiro para mercado e por isso eu acho sempre mais claro --- em especial para inciantes --- declarar os ponteiros em separado para que não se precise ficar fazendo essa operação mental no meio de uma lista assim

mercado        um, *P, *coisa, cem_mercados[100];

para entender que P e coisa são ponteiros. Veja a diferença

mercado    um, cem_mercados[100];
mercado*   P;
mercado*   coisa

Talvez concorde que é mais claro escrever assim.

De volta ao seu programa. Como endereçar as coisas?

Escrevi essa função a partir da sua imprime() e ela só escreve uma linha com o valor do estoque do item. Recebe um ponteiro para mercado

void imprime_estoque(mercado* v)
{
    printf("Total no estoque: %d\n", v->estoque);
}

E considere esse código

	um.estoque = 2;
	printf("a partir de um, deve imprimir 2\n");
	imprime_estoque(&um);

	P = &um;
	printf("a partir de P=&um, deve imprimir 2\n");
	imprime_estoque(P);

	P->estoque = um.estoque + 1;
	printf("(P->estoque = um.estoque + 1) e a MESMA variavel. Soma 1\n");
	imprime_estoque(P);

	cem_mercados[99].estoque = P->estoque + 1;
	printf("(cem_mercados[99].estoque = P->estoque + 1)\n");
	printf("a partir de P copiou para o ultimo dos vetores\n");
	imprime_estoque(cem_mercados + 99);

	printf("( &(cem_mercados[99]) ) uma outra maneira de acessar\n");
	printf("usando o endereco do vetor na posicao 99\n");
	imprime_estoque( &(cem_mercados[99]) );

E mostra isso:

a partir de um, deve imprimir 2
Total no estoque: 2
a partir de P=&um, deve imprimir 2
Total no estoque: 2
(P->estoque = um.estoque + 1) e a MESMA variavel. Soma 1
Total no estoque: 3
(cem_mercados[99].estoque = P->estoque + 1)
a partir de P copiou para o ultimo dos vetores
Total no estoque: 4
( &(cem_mercados[99]) ) uma outra maneira de acessar
usando o endereco do vetor na posicao 99
Total no estoque: 4

Assim você pode comparar as possíveis maneiras de acessar a estrutura a partir do ponteiro.

Sobre seu programa: use sempre o endereço de uma ocorrência de mercado nas funções. Talvez ache favorável declarar todas as funções assim no início do programa:

void imprime(mercado*);
void imprime_estoque(mercado*);
void Leproduto(mercado*);
void Leprodutos(mercado*, int);

Apenas os nomes e tipos. Não precisa colocar nomes de variáveis nem nada. Depois de main() por exemplo você declara as funções normalmente. Assim não precisa ficar se preocupando com a ordem em que estão escritas...E fica fácil de conferir os parâmetros em uso

Se leu até aqui talvez já tenha entendido porque seu programa não funcionou. Mas veja essa Le_produtos() que funciona:

void Leprodutos(mercado* v, int n)
{
    int i;
    for (i = 0; i < n; i++)
    {
        Leproduto( v+i );
    }

A diferença? incrementar o endereço de v a cada chamada para não gravar um produto em cima do outro.... Eis a original

void Leprodutos(mercado *v, int n)
{
    int i; 
    for(i=0;i<n;i++)
    { 
       Leproduto(&v[i]);
    }  
}

Mateus Elias · 21 de setembro de 2019

@arfneto aa sim, obrigado...vou tentar aqui.

arfneto · 21 de setembro de 2019

Olá

Esqueci do programa de teste

#define _CRT_SECURE_NO_WARNINGS
#include    <locale.h>
#include    "memory.h"
#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>


struct Mercado
{
    char nome[30];
    char marca[30];
    float valor;
    int estoque;
};

typedef struct Mercado mercado;

void imprime(mercado*);
void imprime_estoque(mercado*);
void Leproduto(mercado*);
void Leprodutos(mercado*, int);


int main()
{
    int flag = 0;
    int t = 0;
    setlocale(LC_ALL, "Portuguese");
    mercado* P;
    int quant, i;
    mercado um;
    mercado cem_mercados[100];


    um.estoque = 2;
    printf("a partir de um, deve imprimir 2\n");
    imprime_estoque(&um);

    P = &um;
    printf("a partir de P=&um, deve imprimir 2\n");
    imprime_estoque(P);

    P->estoque = um.estoque + 1;
    printf("(P->estoque = um.estoque + 1) e a MESMA variavel. Soma 1\n");
    imprime_estoque(P);

    cem_mercados[99].estoque = P->estoque + 1;
    printf("(cem_mercados[99].estoque = P->estoque + 1)\n");
    printf("a partir de P copiou para o ultimo dos vetores\n");
    imprime_estoque(cem_mercados + 99);

    printf("( &(cem_mercados[99]) ) uma outra maneira de acessar\n");
    printf("usando o endereco do vetor na posicao 99\n");
    imprime_estoque( &(cem_mercados[99]) );

    // if (flag == 0) return 0;

    printf("Quantidade de cadastros: ");
    scanf("%d", &quant);

    t = quant * sizeof(mercado);
    P = (mercado*)malloc(t);
    if (P == NULL)
    {
        printf("Alocação indisponível\n");
        return 1;
    }
    else
    {
        printf("Alocados %d bytes para %d estruturas \"mercado\" de %d bytes\n",
            t, quant, sizeof(mercado));
    }

    puts("");
    Leprodutos(P, quant);
        for (i = 0; i < quant; i++)
    {
        imprime( P+i );
    }

    return 0;
}


void imprime(mercado* v)
{
    printf("Nome: %s\n", v->nome);
    printf("Marca: %s\n", v->marca);
    printf("Valor: %.2f\n", v->valor);
    printf("Estoque: %d\n", v->estoque);
}


void imprime_estoque(mercado* v)
{
    printf("Total no estoque: %d\n", v->estoque);
}


void Leproduto(mercado* v)
{
    printf("Nome do Produto: ");
    fflush(stdin);
    scanf("%s", v->nome);
    printf("Marca do Produto: ");
    fflush(stdin);
    scanf("%s", v->marca);
    printf("Valor do Produto: ");
    scanf("%f", &(v->valor));
    printf("Quantidade em Estoque: ");
    scanf("%d", &(v->estoque));
    printf("\n\n");
}


void Leprodutos(mercado* v, int n)
{
    int i;
    for (i = 0; i < n; i++)
    {
        Leproduto(v + i);
    }
}