C++ Algoritmo retornando sempre o valor 0

Cairo Alberto · 28 de setembro de 2021

dentro do meu programa tem algumas funções onde o mesmo calcula algumas características de um triangulo tal como:

tipo de triangulo pelo tamanho dos lados: (sempre retorna 'Equilátero')
tipo de triangulo pelo ângulo: (sempre retorna 'Retângulo")
calculo da área do triangulo: (sempre retorna '0')

estou usando o return (variável com o valor de interesse), mas mesmo assim o valor não parece passar entre as funções
imagino que o problema esteja na função que verifica que os valores são validos, que não está retornando o valor correto.
alguém me ajuda ai:
mais detalhes:
https://photos.app.goo.gl/MP61CdMBEnzwCAia9

#include "calculotriangulo.h"

#include <math.h>





namespace aogcalc {





float Triangulo::getLadoA() const

{

return ladoA;

}



float Triangulo::getLadoB() const

{

return ladoB;

}

float Triangulo::getLadoC() const

{

return ladoC;

}



Triangulo::Triangulo():

ladoA(0),

ladoB(0),

ladoC(0)



{

}

float Triangulo::setLados(int valorA, int valorB, int valorC){

//esses "if"s estão funcionando corretamente

if(valorA<=0 || valorB<=0 || valorC<=0)throw QString("Nenhum dos lados podem ser menor ou igual a 0");{



}



//verificar se é triangulo

if (valorA>valorB+valorC || valorB>valorA+valorC || valorC>valorA+valorB)throw QString("Triângulo inválido.");

//atribuição





return(valorA, valorB, valorC);







}



QString Triangulo::IdentificarLadoTriangulo(){



QString aux;

if(getLadoA() == getLadoB() && getLadoB() == getLadoC()) {aux = ("Equilátero");}

else if( (getLadoA()!=getLadoB()) && (getLadoA()!=getLadoC()) && (ladoB!=getLadoC())){aux=("Isóceles");}

else{aux=("Escaleno");}

return aux;

}



QString Triangulo::IdentificarAnguloTriangulo(){

QString aux;

if(getLadoA()<getLadoB()+getLadoC()) {aux = ("Acutângulo");}

else if( (getLadoA()>getLadoB()+getLadoC()) && (getLadoB() !=getLadoC())){aux=("Obtusângulo");}

else if(pow(getLadoA(),2)==pow(getLadoB(),2)+pow(getLadoC(),2)){aux=("Retângulo");}

return aux;

}

float Triangulo::calcularArea(){

//raizQuadrada(T*(T-A)*(T-B)*(T-C)) onde T = (A+B+C)/2.

float T = (getLadoA()+getLadoB()+getLadoC())/2.0;

return (sqrt(T*(T-getLadoA())*(T-getLadoB())*(T-getLadoC())));



}

}

#include "mainwindow.h"

#include "ui_mainwindow.h"

#include <QMessageBox>



#include <QString>



MainWindow::MainWindow(QWidget *parent)

: QMainWindow(parent)

, ui(new Ui::MainWindow)

{

ui->setupUi(this);

}



MainWindow::~MainWindow()

{

delete ui;

}





void MainWindow::on_pushButtonExecultar_clicked()

{

try {

aogcalc::Triangulo objetoT;



objetoT.setLados(ui->lineEditLadoA->text().toFloat(), ui->lineEditLadoB->text().toFloat(),ui->lineEditLadoC->text().toFloat() );















QString saida;



saida+= "Triangulo";

saida += "\nCalculo de triangulo ";

saida += "\nBaseado nos lados este triangulo é " ;

saida+= objetoT.IdentificarLadoTriangulo();

saida += ".\nBaseado nos angulos este triangulo é ";

saida +=objetoT.IdentificarAnguloTriangulo();

saida += ".\nA área do triangulo é de: " + QString::number(objetoT.calcularArea());













ui->textEditSaida->setText(saida);



} catch (QString &erro) {

QMessageBox::information(this,"ERRO DO SISTEMA", erro);

}



}



void MainWindow::on_pushButtonLimpar_clicked()

{



ui->textEditSaida->clear();

}

#ifndef CALCULOTRIANGULO_H
#define CALCULOTRIANGULO_H
#include <QString>

namespace aogcalc {
class Triangulo
{
private:

    float ladoA;
    float ladoB;
    float ladoC;

public:
    Triangulo();
    float calcularArea();
    QString IdentificarLadoTriangulo();
    QString IdentificarAnguloTriangulo();

    float getLadoA() const;
    float getLadoB() const;
    float getLadoC() const;

    float setLados(int valorA, int valorB, int valorC);
};
}

#endif // CALCULOTRIANGULO_H

codigo rapido · 28 de setembro de 2021

ta bem parecido com um exercicio que fiz a uns anos...
https://tivideotutoriais.blogspot.com/2020/03/exercicios-antigos-em-linguagem-c.html

Mas lembrando pelo seu post, decidi atualizar:
https://tivideotutoriais.blogspot.com/2021/09/linguagem-c-classificando-triangulos.html

Quem sabe lhe dá uma ideia.
Eu tive problemas por usar numero na forma 2 no lugar de 2.0...

Felipecfk · 28 de setembro de 2021

Citação

ui->textEditSaida->clear();

Não conheço muito c++ mas o que esse comando acima faz exatamente?

Citação

Triangulo::Triangulo(): ladoA(0), ladoB(0), ladoC(0)

Eu imagino que ele esteja resetando os valores que você coloca para o default e por isso na imagem que você deixou com os valores:

13,5 12,9 e 15,3 ele está acusando de não ter área, porque os valores estão zerando de alguma forma, isso explica também porque o programa acusa o triângulo de ser equilátero (todos os valores são iguais, ou seja, zero).

Eu perguntei desse clear() porque talvez fosse isso, mas não tenho certeza. Alguma parte do seu código ou está recebendo e não retornando, ou deve estar simplesmente resetando depois de receber os valores (percebi que algumas funções você deixou como 'const' não sei se influencia).

arfneto · 28 de setembro de 2021

@Cairo Alberto acho que sabe que o espaçamento que usou não está assim facilitando ler o seu programa.

Evite nomes assim grandes para classes, ao menos enquanto está testando.

Cairo Alberto · 28 de setembro de 2021

11 minutos atrás, Felipecfk disse:

Não conheço muito c++ mas o que esse comando acima faz exatamente?

eu coloquei ele no botão 'limpar', para limpar a saida de texto do programa, o comando não mexe com o valor das variaveis, apenas zera a saida de texto 'textEditSaida'

14 minutos atrás, Felipecfk disse:

Triangulo::Triangulo(): ladoA(0), ladoB(0), ladoC(0)

Eu imagino que ele esteja resetando os valores que você coloca para o default e por isso na imagem que você deixou com os valores:

13,5 12,9 e 15,3 ele está acusando de não ter área, porque os valores estão zerando de alguma forma, isso explica também porque o programa acusa o triângulo de ser equilátero (todos os valores são iguais, ou seja, zero).

.ai na verdade eu estou inicializando as variáveis, se notar está fora do escopo da função.

16 minutos atrás, Felipecfk disse:

valores (percebi que algumas funções você deixou como 'const' não sei se influencia).

isso apenas serve para o compilador me lembrar que é um caminho cujo o objetivo não é mudar o valor da variavel, assim mantendo constante 'const' por isso eu uso o getVariavel, onde o objetivo é apenas pegar o valor "get value", se o objetivo fosse modificar o valor utilizaria o caminho set "setLados(int ladoA,etc..)

@arfneto sim eu sei, estou usando um monitor 4k, enquanto esta na fase de teste, o programa eu deixo bem espaçado para ficar mais confortável para mim ja que a escala do PC esta em 100% e as coisas tendem a ficar bem pequenas, mas pretendo organiza-las, antes de entregar o código

quanto os nomes das classes, me lembrarei , Obrigado
o programa que estou usando, QT, tem um sistema de auto-complete, que ajuda na hora de escrever, nomes grandes nunca me incomodou, mas imagino que não seja todos que tenham.

o professos falou para manter curta apenas os nomes das namespace.

Obrigado@codigo rápido, vou dar uma olhada.

arfneto · 28 de setembro de 2021

54 minutos atrás, Cairo Alberto disse:

quanto os nomes das classes, me lembrarei , Obrigado
o programa que estou usando, QT, tem um sistema de auto-complete, que ajuda na hora de escrever, nomes grandes nunca me incomodou, mas imagino que não seja todos que tenham

Quase todo ambiente moderno tem um auto-complete sofisticado, mas isso não vai impedir que uma expressão simples em seu programa acabe usando 80 colunas e fique ruim demais de ler.

Mesmo um monitor de 1m e 8K não vai ajudar muito também.

E se está postando algo em um forum público para conseguir ajuda talvez concorde que o conforto e a característica de seu ambiente não sejam assim relevantes.

Seu programa tem vários erros e um outro número de "quase-erros".

Vou mostrar alguns apenas

float Triangulo::setLados(int valorA, int valorB, int valorC)
{
    // esses "if"s estão funcionando corretamente
    if (valorA <= 0 || valorB <= 0 || valorC <= 0)
        throw QString("Nenhum dos lados podem ser menor ou igual a 0");
    {
    }
    // verificar se é triangulo
    if (valorA > valorB + valorC || valorB > valorA + valorC ||
        valorC > valorA + valorB)
        throw QString("Triângulo inválido.");
    // atribuição
    return (valorA, valorB, valorC);
}

Que pretende com essa função? Ela retorna um float? que seria? E essa triplet no retorno? E provavelmente os vértices devem ser todos float e não int

  return (valorA, valorB, valorC);

E isso provavelmente era apenas um construtor.

Triangulo::Triangulo() : ladoA(0), ladoB(0), ladoC(0) {}

E se isso é o construtor padrão entenda que, apesar de não estar errado totalmente, deve escrever o simples:

       public:

        Triangulo::Triangulo() : Triangulo(0, 0, 0){};

        Triangulo::Triangulo(float valorA, float valorB, float valorC) :
            ladoA(valorA), ladoB(valorB), ladoC(valorC){};

definindo o construtor padrão a partir do construtor parametrizado. É o comum.

Ao invés de throw prefira retornar algo das funções enquanto estiver testando.

namespaces e exceções e QT não vão fazer diferença para testar a classe Triangulo. Se está aprendendo talvez não deva misturar as coisas... C++ é muito flexível. Use polimorfismo e declare os construtores do modo mais legível. como mostrei. Não misture as classes com a interface. C++ tem encapsulamento. Um Triangulo nada tem a ver com a interface até você colocar uma QString como retorno da função...

não use acentos em comentários ou strings durante um teste simples como esse, em especial se pode acabar em computadores de terceiros. Não acrescenta muito, se algo

Compare

QString Triangulo::IdentificarLadoTriangulo()
{
    QString aux;
    if (getLadoA() == getLadoB() && getLadoB() == getLadoC())
    {
        aux = ("Equilátero");
    }
    else if (
        (getLadoA() != getLadoB()) && (getLadoA() != getLadoC()) &&
        (ladoB != getLadoC()))
    {
        aux = ("Isóceles");
    }
    else
    {
        aux = ("Escaleno");
    }
    return aux;
}

Não precisa dessas duas QString.
A segunda condição está errada: o teste é para Escaleno
A grafia correta é Isósceles
Entenda que essa é uma função da classe. Não precisa dos getters: tem acesso a todos os campos.

Podia ter escrito o simples:

std::string Triangulo::IdentificarLadoTriangulo()
{
    if (ladoA == ladoB && ladoB == ladoC) return "Equilatero";
    if (    ladoA != ladoB &&
            ladoA != ladoC &&
            ladoB != ladoC ) return "Escaleno";
    return "Isosceles";
}

E no retorno colocar o resultado na QString...

Essa função

QString Triangulo::IdentificarAnguloTriangulo()
{
    QString aux;
    if (getLadoA() < getLadoB() + getLadoC()) { aux = ("Acutângulo"); }
    else if (
        (getLadoA() > getLadoB() + getLadoC()) &&
        (getLadoB() != getLadoC()))
    {
        aux = ("Obtusângulo");
    }
    else if (
        pow(getLadoA(), 2) == pow(getLadoB(), 2) + pow(getLadoC(), 2))
    {
        aux = ("Retângulo");
    }
    return aux;

Está muito complicada. Mas note que no caso do triângulo retângulo só testa para a hipotenusa em A. E se for B ou C? Então está também errada.

Em main não há referência ao namespace aogcalc...

Cairo Alberto · 28 de setembro de 2021

5 horas atrás, arfneto disse:
Quase todo ambiente moderno tem um auto-complete sofisticado, mas isso não vai impedir que uma expressão simples em seu programa acabe usando 80 colunas e fique ruim demais de ler.

Mesmo um monitor de 1m e 8K não vai ajudar muito também.

E se está postando algo em um forum público para conseguir ajuda talvez concorde que o conforto e a característica de seu ambiente não sejam assim relevantes.

Seu programa tem vários erros e um outro número de "quase-erros".

Vou mostrar alguns apenas
float Triangulo::setLados(int valorA, int valorB, int valorC)
{
    // esses "if"s estão funcionando corretamente
    if (valorA <= 0 || valorB <= 0 || valorC <= 0)
        throw QString("Nenhum dos lados podem ser menor ou igual a 0");
    {
    }
    // verificar se é triangulo
    if (valorA > valorB + valorC || valorB > valorA + valorC ||
        valorC > valorA + valorB)
        throw QString("Triângulo inválido.");
    // atribuição
    return (valorA, valorB, valorC);
}
Que pretende com essa função? Ela retorna um float? que seria? E essa triplet no retorno? E provavelmente os vértices devem ser todos float e não int

O professor insiste que as variáveis seja privada, e que para manipula-la utilize os 'getter and setter'

a função está funcionando como setter, dos três valores ao mesmo tempo (insistência do professor),

os if serve para verificar se os valores colocador no programa estão de acordo com os cálculos(fazendo o teste se os valores são menor que 0 ou se forma um triangulo válido) jogando um erro caso não (apesar de que acho que essa não seja a sua duvida)

realmente era para retornar um float, ja corrigi isso, Obrigado

o objetivo de setter, é testar os valores antes de atribui-los

não sei o que é um triplet

5 horas atrás, arfneto disse:
  return (valorA, valorB, valorC);
E isso provavelmente era apenas um construtor.
Triangulo::Triangulo() : ladoA(0), ladoB(0), ladoC(0) {}
E se isso é o construtor padrão entenda que, apesar de não estar errado totalmente, deve escrever o simples:
       public:

        Triangulo::Triangulo() : Triangulo(0, 0, 0){};

        Triangulo::Triangulo(float valorA, float valorB, float valorC) :
            ladoA(valorA), ladoB(valorB), ladoC(valorC){};
definindo o construtor padrão a partir do construtor parametrizado. É o comum.

Ao invés de throw prefira retornar algo das funções enquanto estiver testando.

namespaces e exceções e QT não vão fazer diferença para testar a classe Triangulo. Se está aprendendo talvez não deva misturar as coisas... C++ é muito flexível. Use polimorfismo e declare os construtores do modo mais legível. como mostrei. Não misture as classes com a interface. C++ tem encapsulamento. Um Triangulo nada tem a ver com a interface até você colocar uma QString como retorno da função...

não use acentos em comentários ou strings durante um teste simples como esse, em especial se pode acabar em computadores de terceiros. Não acrescenta muito, se algo

"return (valorA, valorB, valorC)" o objetivo era retornar os valores para atribui-los as determinadas variáveis "ladoA, ladoB e ladoC", é aqui que eu acho que é o problema de retornar o valor errado, mas não tenho certeza, ou como arrumar

"Triangulo::Triangulo(): ladoA(0), ladoB(0), ladoC(0) { };" o professor falou que isso era para inicializar as variáveis de acordo com o diagrama de classe, mas o meu professor não aceita algo diferente, então o programa original vai ficar assim, mas vou fazer uma cópia do código fonte e fazer do seu jeito, para já ir treinando, Agradeço

o professor pediu para usar o throw, para caso de exceções, retornar algo da variável não sei se entendi

como falei, o professor prefere a metodologia dele, por isso faço desse jeito, mas não pretendo ficar preso a isso, treinarei de acordo com o que falou, muito Obrigado. (vou evitar os acentos, é só mania de escrita)

5 horas atrás, arfneto disse:

QString Triangulo::IdentificarLadoTriangulo()
{
    QString aux;
    if (getLadoA() == getLadoB() && getLadoB() == getLadoC())
    {
        aux = ("Equilátero");
    }
    else if (
        (getLadoA() != getLadoB()) && (getLadoA() != getLadoC()) &&
        (ladoB != getLadoC()))
    {
        aux = ("Isóceles");
    }
    else
    {
        aux = ("Escaleno");
    }
    return aux;
}

Não precisa dessas duas QString.
A segunda condição está errada: o teste é para Escaleno
A grafia correta é Isósceles
Entenda que essa é uma função da classe. Não precisa dos getters: tem acesso a todos os campos.

Podia ter escrito o simples:

std::string Triangulo::IdentificarLadoTriangulo()
{
    if (ladoA == ladoB && ladoB == ladoC) return "Equilatero";
    if (    ladoA != ladoB &&
            ladoA != ladoC &&
            ladoB != ladoC ) return "Escaleno";
    return "Isosceles";
}

E no retorno colocar o resultado na QString...

Essa função

QString Triangulo::IdentificarAnguloTriangulo()
{
    QString aux;
    if (getLadoA() < getLadoB() + getLadoC()) { aux = ("Acutângulo"); }
    else if (
        (getLadoA() > getLadoB() + getLadoC()) &&
        (getLadoB() != getLadoC()))
    {
        aux = ("Obtusângulo");
    }
    else if (
        pow(getLadoA(), 2) == pow(getLadoB(), 2) + pow(getLadoC(), 2))
    {
        aux = ("Retângulo");
    }
    return aux;

Está muito complicada. Mas note que no caso do triângulo retângulo só testa para a hipotenusa em A. E se for B ou C? Então está também errada.

Em main não há referência ao namespace aogcalc...

ok removerei a QString, realmente da para fazer sem, apenas não caiu a ficha,
vou inverter o isósceles com o escaleno, obrigado
obrigado corrigirei a grafia,
ok entendi

vou corrigir a função de ângulos, Obrigado.
O main foi gerado automaticamente, pelo programa, o Professor falou para não mexer em nada, foi o que eu fiz, por isso a minha namespace não está nela

O programa esta respondendo agora, só vou testar para ver se está tudo funcionando como deveria:
https://photos.app.goo.gl/6qd78BmS3bzzqHnZ6

o problema é que eu fiz o setter com float, o certo era com void

6 horas atrás, arfneto disse:

Entenda que essa é uma função da classe. Não precisa dos getters: tem acesso a todos os campos.

Obrigado@arfneto , isso aqui me fez cair a ficha.

arfneto · 28 de setembro de 2021

3 horas atrás, Cairo Alberto disse:

O professor insiste que as variáveis seja privada, e que para manipula-la utilize os 'getter and setter'

Nada tem a ver com o caso. Os métodos da classe não precisam de getters ou setters e é simplesmente errado usar.

3 horas atrás, Cairo Alberto disse:

"return (valorA, valorB, valorC)" o objetivo era retornar os valores para atribui-los as determinadas variáveis "ladoA, ladoB e ladoC"

Está muito errado. Isso não está na linguagem. Você tem um livro? Seu curso adota um livro?

Veja essa:

int Triangulo::setLados(float valorA, float valorB, float valorC)
{
    if (valorA <= 0 || valorB <= 0 || valorC <= 0) return -1;
    if (valorA > valorB + valorC || valorB > valorA + valorC ||
        valorC > valorA + valorB)
        return -2;
    ladoA = valorA;
    ladoB = valorB;
    ladoC = valorC;
    return 0; // ok
}

É só isso

3 horas atrás, Cairo Alberto disse:

O main foi gerado automaticamente, pelo programa, o Professor falou para não mexer em nada, foi o que eu fiz, por isso a minha namespace não está nela

Seu professor está errado, se disse isso.

3 horas atrás, Cairo Alberto disse:

o problema é que eu fiz o setter com float, o certo era com void

Isso era para ser um construtor e eu te mostrei como escrever

       public:
        Triangulo::Triangulo() : Triangulo(0, 0, 0){};

        Triangulo::Triangulo(float valorA, float valorB, float valorC) :
            ladoA(valorA), ladoB(valorB), ladoC(valorC){};

Teste a classe Triangulo em separado. É mais esperto. Para isso se escreve uma classe como tal. Separada.

Cairo Alberto · 28 de setembro de 2021

@arfneto
Eu criei o programa de acordo com o que o meu professor quer, e a foto é do programa funcionando de acordo com o método dele,

Mas como falei anteriormente, irei fazer o programa novamente da forma que você me apresentou, afinal aprender nunca é demais.
Novamente: Muito Obrigado, por me ajudar nesse tópico.