C Como fazer para minha Calculadora diferir numeros de caracteres

[W0xer]

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <_mingw.h>



char teste;

//coeficientes
float coeficiente_a = 0, coeficiente_b = 0, coeficiente_c = 0;
float *ptr;

//vertices
float vertice_x, vertice_y;
float delta;

//tráfego de variáveis
float recebe_valores();
float calcula_valores();

float recebe_valores()
{
    printf("\t\t\t\t\t\t<Calculadora de vertices>\n\n");
    printf("\t\tInsira os coeficientes para a equacao: ax^2 + bx + c\n");
    printf("\t\t\ta = %.2f\n\t\t\tb = %.2f\n\t\t\tc = %.2f\n", coeficiente_a, coeficiente_b, coeficiente_c);

    ptr = &coeficiente_a;
    scanf("%f", ptr);

    if (coeficiente_a <= 0)
    {
        printf("\t\tO coeficiente 'a' precisa ser necessariamente maior que 0, se não for a equacao deixa de ser quadratica e se torna linear\n\n");
        recebe_valores();
    }
    else
    {
        coeficiente_a = *ptr;
        ptr = 0;

        printf("\t\t\ta = %.2f\n\t\t\tb = %.2f\n\t\t\tc = %.2f\n", coeficiente_a, coeficiente_b, coeficiente_c);

        ptr = &coeficiente_b;
        scanf("%f", ptr);
    }
}
float calcula_valores()
{
    printf("Calculando o vertice Y:\n");
    delta = (-coeficiente_b) * (-coeficiente_b) - 4 * coeficiente_a * coeficiente_c;

    vertice_y = delta / 4 * coeficiente_a;

    printf("Vertice Y = (0,%.2f)\n", vertice_y);

    printf("Calculando o vertice X:\n");

    vertice_x = coeficiente_b / 2 * coeficiente_a;

    printf("Vertice X = (%.2f,0)\n", vertice_x);
}
int main()
{
    recebe_valores();
    calcula_valores();
}
//por favor me ajudem, eu quero saber como fazer isso, eu passei madrugadas trabalhando nisso

 

[arfneto]

Você viu a documentação?

 

TESTE o retorno de scanf(). SEMPRE. É ingênuo não testar. scanf() retorna um int, de -1 até o total de especificadores passados.

 

Assim, scanf( "%f %d %d %d"... ) pode retornar até 4 conforme o que conseguir ler.

 

Se quer tratar a entrada para determinar expressões, tipo a = 2 * 3, não use scanf(). Use fgets() leia a linha toda e analise o que veio...

 

Note que existem atoi(), atof(), atod(), strtod() e outras funções que convertem strings para números, e você sempre pode escrever uma para ter mais controle

[Flávio Pedroza]

if (coeficiente_a <= 0)
    {
        printf("\t\tO coeficiente 'a' precisa ser necessariamente maior que 0, se não for a equacao deixa de ser quadratica e se torna linear\n\n");
        recebe_valores();
    }

"a" pode ser menor que zero. Não pode ser IGUAL a zero.

if (coeficiente_a == 0)
    {
        printf("\t\tO coeficiente 'a' precisa ser necessariamente diferente de 0, se não for a equacao deixa de ser quadratica e se torna linear\n\n");
        recebe_valores();
    }

Além disso, faltou você ler o "coeficiente_c"

[W0xer]

putz amigo, de fato ainda tem muita coisa pra fazer e pra revisar nesse negócio, eu estava pensando em desistir na verdade, eu nem vou usar mais esse programa. Eu na verdade só postei esse negócio aqui porque nunca tinha postado nada e vejo todo mundo participando e se interagindo, é bem legal essa comunidade. Mas enfim, obrigado pela ajuda, é sempre bom ter contato com pessoas experientes, boa noite.

[arfneto]

18 minutos atrás, W0xer disse:

putz amigo, de fato ainda tem muita coisa pra fazer e pra revisar nesse negócio, eu estava pensando em desistir na verdade, eu nem vou usar mais esse programa. Eu na verdade só postei esse negócio aqui porque nunca tinha postado nada e vejo todo mundo participando e se interagindo, é bem legal essa comunidade. Mas enfim, obrigado pela ajuda, é sempre bom ter contato com pessoas experientes, boa noite.

 

Desistir não devia ser uma opção.

 

Escreva em torno dos dados. Tem muitas maneiras de fazer qualquer coisa.

 

Sobre o programa

 

Não entendi o propósito de seu programa, mas por exemplo

 

// tráfego de variáveis
float recebe_valores();
float calcula_valores();

 

Esse comentário não ajuda muito, talvez pudesse evitar. 

 

Mas recebe_valores retorna um float. Um só. No entanto o programa gira em torno de coeficientes....

 

É conhecida a notação para polinômios, com os coeficientes usados como escreveu...
 

    y = ax + b

    y = ax^2 + bx + c

    y = ax^3 + bx^2 + cx + d
      
      ...

 

Então não te parece melhor que recebe_valores() devolva os coeficientes arrumadinhos??? Se sabe que vai usar nesse programa apenas grau 2 então são 3 coeficientes?

 

Veja como pode ser mais simples:

 

#include <stdio.h>
int         recebe_valores();

int main(void)
{
    float coef[3] = {0.};
    int   res = recebe_valores(coef);

    if (res < 0)
    {
        printf("Deu erro!\n");
        return -1;
    };

    printf(
        "recebeu: a= %f, b = %f, c = %f\n", coef[0], coef[1], coef[2]);
    return 0;
}


int         recebe_valores(float v[])
{
    v[0] = 1.1f, v[1] = 2.2f, v[2] = 3.3f;
    return 0;
}

 

Outra opção seria alocar e retornar o vetor na hora, como em 
 

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

float* recebe_valores();

int main(void)
{
    float* coef = recebe_valores();

    if (coef == NULL)
    {
        printf("Deu erro!\n");
        return -1;
    };

    printf(
        "recebeu: a= %f, b = %f, c = %f\n", coef[0], coef[1], coef[2]);
    free(coef); // apaga o vetor
    return 0;
}

float* recebe_valores()
{
    float* v = (float*)malloc(3 * sizeof(float));
    v[0]     = 1.1f;
    v[1]     = 2.2f;
    v[2]     = 3.3f;
    return v;
}

 

E o resultado seria o mesmo

 

recebeu: a= 1.100000, b = 2.200000, c = 3.300000

 

Nos dois casos tem como retornar um erro, porque afinal pode não conseguir ler os valores.

[W0xer]

Sim, bem legal isso. Eu ainda tenho muito a aprender, e eu não vou desistir da programação, eu to desistindo desse código estúpido meu que eu fiz quando criança, mas obrigado aí amigo, abraço.

[arfneto]

Li as duas funções e parece que na verdade sequer são vértices: trata-se apenas de encontrar raízes usando a conhecida fórmula lá do ensino fundamental. Se entendeu o que eu expliquei então sabe que pode usar a mesma opção para calcular as raízes, já que um polinômio de grau x tem x raizes então pode usar um vetor de coeficientes para calcular um vetor de raízes e a vida segue.

 

E já deve ter percebido que é muito chato usar variáveis com nomes de 10 letras que diferem por uma e aparecem numa expressão...

 

    delta = (-coeficiente_b) * (-coeficiente_b) -
            4 * coeficiente_a * coeficiente_c;

 

E usando um vetor e os índices pode ser mais simples.

 

Um outro exemplo: calculando as raízes

 

float* calcula(float coef[])
{
    float delta = coef[1]*coef[1] - 4 * (coef[0] * coef[2]);
    if (delta < 0) return NULL; // sem solucao
    delta = (float) sqrt(delta);
    float* v = (float*)malloc(2 * sizeof(float));
    v[0]     = (-coef[1] + delta) / (coef[0] + coef[0]);
    v[1]     = (-coef[1] - delta) / (coef[0] + coef[0]);
    return v;
}

 

Pode achar mais simples ler e escrever assim, afinal vai usar os coeficientes e calcular as raízes...

 

Um programa completo

 

Rode esse exemplo e talvez entenda melhor o que estou dizendo...

 

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

float* calcula();
float* recebe();

int main(void)
{
    float* coef = recebe(); // le os dados

    if (coef == NULL)
    {   printf("Deu erro!\n");
        return -1;
    };
    printf(
        "Para esses valores a= %f, b = %f, c = %f\n",
        coef[0], coef[1], coef[2]);

    // se leu entao calcula as araizes
    float* sol = calcula(coef);
    if (sol == NULL)
    {   printf("não tem raizes!\n");
        return -1;
    };
    printf(
        "As raizes sao: %f e %f\n", sol[0], sol[1]);

    free(coef);  // apaga o vetor de coeficientes
    free(sol);  // apaga o vetor de raizes
    return 0;
}

float* recebe()
{
    float* v = (float*)malloc(3 * sizeof(float));
    v[0]     = 1.0f;
    v[1]     = -4.0f;
    v[2]     = 4.0f;
    return v;
}

float* calcula(float coef[])
{
    float delta = coef[1]*coef[1] - 4 * (coef[0] * coef[2]);
    if (delta < 0) return NULL; // sem solucao
    delta = (float) sqrt(delta);
    float* v = (float*)malloc(2 * sizeof(float));
    v[0]     = (-coef[1] + delta) / (coef[0] + coef[0]);
    v[1]     = (-coef[1] - delta) / (coef[0] + coef[0]);
    return v;
}