Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » Función en C similar a VALF( ) de BASIC

C/Visual C - Función en C similar a VALF( ) de BASIC

Volver
Nuevo Tema
<<>>
 
Vista:

Función en C similar a VALF( ) de BASIC

Publicado por Dj Roly (6 intervenciones) el 01/05/2003 03:46:17
Necesito saber que función en C o C++ es similar a la función o comando VALF( ) del BASIC que viene en las calculadoras CASIO fx880P.

la función en mención convierte una expresión (una fórmula lógica o matemática) almacenada en una variable tipo char a una verdadera expresión. Por ejemplo:
A$="25/5"
PRINT VALF(A$)

respuesta = 5
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Función similar a VALF() en C/C++

Publicado por Alejandro (1153 intervenciones) el 19/05/2025 23:44:37
En C o C++, no existe una función incorporada que sea directamente equivalente a `VALF()` del BASIC de las calculadoras CASIO, que evalúa expresiones matemáticas almacenadas como cadenas de caracteres. Sin embargo, puedes lograr un comportamiento similar utilizando bibliotecas externas o implementando tu propia función de evaluación de expresiones.

Opción 1: Usar una biblioteca externa



Una de las bibliotecas más populares para evaluar expresiones matemáticas en C++ es ExprTk. Esta biblioteca permite evaluar expresiones matemáticas de forma sencilla. Aquí te muestro cómo usarla:

1. Descargar ExprTk: Puedes encontrar la biblioteca en su sitio web oficial: https://www.partow.net/programming/exprtk/.

2. Ejemplo de código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
#include "exprtk.hpp" // Asegúrate de incluir el archivo de cabecera de ExprTk
 
int main() {
    std::string expresion = "25/5"; // La expresión que deseas evaluar
    exprtk::parser<double> parser; // Crea un parser para expresiones de tipo double
    exprtk::expression<double> exp; // Crea una expresión
 
    if (parser.compile(expresion, exp)) { // Compila la expresión
        double resultado = exp.value(); // Evalúa la expresión
        std::cout << "Resultado: " << resultado << std::endl; // Muestra el resultado
    } else {
        std::cerr << "Error al compilar la expresión." << std::endl;
    }
 
    return 0;
}

Opción 2: Implementar tu propia evaluación



Si prefieres no usar bibliotecas externas, puedes implementar una función simple para evaluar expresiones matemáticas. Sin embargo, esto puede ser más complicado y requerir un análisis más profundo de la cadena.

Aquí hay un ejemplo básico que solo maneja operaciones simples:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <iostream>
#include <string>
#include <sstream>
 
double evaluarExpresion(const std::string& expresion) {
    double resultado;
    std::istringstream iss(expresion);
    char operacion;
    double numero;
 
    iss >> resultado; // Lee el primer número
 
    while (iss >> operacion >> numero) { // Lee la operación y el siguiente número
        switch (operacion) {
            case '+':
                resultado += numero;
                break;
            case '-':
                resultado -= numero;
                break;
            case '*':
                resultado *= numero;
                break;
            case '/':
                resultado /= numero;
                break;
            default:
                std::cerr << "Operación no válida." << std::endl;
                return 0;
        }
    }
 
    return resultado;
}
 
int main() {
    std::string expresion = "25 / 5"; // La expresión que deseas evaluar
    double resultado = evaluarExpresion(expresion);
    std::cout << "Resultado: " << resultado << std::endl; // Muestra el resultado
 
    return 0;
}

Consideraciones



- La implementación de tu propia función de evaluación puede ser limitada y no manejará todas las complejidades de las expresiones matemáticas (como paréntesis o precedencia de operadores).
- Usar una biblioteca como ExprTk es más robusto y flexible, permitiendo evaluar expresiones más complejas de manera sencilla.

Ambas opciones te permitirán lograr un comportamiento similar al de `VALF()` en C o C++. ¡Espero que esto te sea útil, D.J.!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar