Pregunta de sintaxis de C ++: if var! = Type int

Question

Estoy tratando de escribir una declaración if pero no puedo encontrar la forma de expresión adecuada para usar. Estoy pensando en escribir algo como esto:

if ( var != type(int) )

Sin embargo, no estoy seguro de cómo hacer esto, y este método no funciona.

¿Al menos estoy pensando en la línea correcta?

Answer 1

Parece que está intentando sobrecargar una función:

void foo(int i)
{
    // stuff
}

void foo(float f)
{
    // stuff
}

int main(void)
{
    int i = 10;
    float f = 1.0f;

    foo(i); // calls foo(int)
    foo(f); // calls foo(float)
}

Si desea int -comportamiento especial y luego algo más en todos los demás casos, puede usar plantillas:

template <typename T>
void foo(T t)
{
    // T is something
}

template <>
void foo(int i)
{
    // for int's only
}

int main(void)
{
    int i = 10;
    float f = 1.0f;
    double d = 2.0;

    foo(i); // calls specialized foo
    foo(f); // calls generic foo
    foo(d); // calls generic foo
}

---

Según su comentario ( " La tarea en cuestión es un programa simple: tome dos enteros ingresados ??por el usuario y agréguelos. Restrinja la entrada al entero solamente. Puedo hacerlo en Python y estoy pensando en ese sentido. . if num1! = type (int): print " No ingresó un número entero, ingrese un número entero. " más: continúe " ), desea algo como esto:

#include <iostream>

int main(void)
{
    int i;
    std::cin >> i;

    if (std::cin.fail())
    {
        std::cout << "Not valid!" << std::endl;
    }
    else
    {
        // ...
    }
}

Esto notificará entradas no válidas como " @ # $ " ;, " r13 " ;, pero no capturará casos como " 34fg " ;, " 12 $ #% " , porque leerá int y se detendrá en " fg " y " $ #% " ;, respectivamente.

Para verificar eso, tendrá que leer en una línea de entrada y luego tratar de convertir esa línea en el tipo que desee. ( Gracias, litb ). Eso significa que su pregunta es más como esta pregunta :

#include <iostream>
#include <sstream>
#include <string>

int main(void)
{
    std::string input;
    std::getline(std::cin, input);

    std::stringstream ss(input);
    int i;
    ss >> i;

    if (ss.fail() || !(ss >> std::ws).eof())
    {
        std::cout << "Not valid!" << std::endl;
    }
    else
    {
        // ...
    }
}

Esto hace lo siguiente: obtener entrada y ponerla en un stringstream . Luego, después de analizar el int , transmita cualquier espacio en blanco restante. Después de eso, si eof es falso, esto significa que hay caracteres sobrantes; la entrada no era válida.

Esto es mucho más fácil de usar envuelto en una función. En la otra pregunta, el reparto fue refactorizado; en esta pregunta estamos usando el elenco, pero envolviendo la entrada junto con él.

#include <iostream>
#include <sstream>
#include <string>

bool parse_int(int& i)
{
    std::string input;
    std::getline(std::cin, input);

    std::stringstream ss(input);
    ss >> i;

    return !(ss.fail() || !(ss >> std::ws).eof());
}

int main(void)
{
    int i;

    if (!parse_int(i))
    {
        std::cout << "Not valid!" << std::endl;
    }
    else
    {
        // ...
    }
}

O más genéricamente:

#include <iostream>
#include <sstream>
#include <string>

template <typename T>
bool parse_type(T& t)
{
    std::string input;
    std::getline(std::cin, input);

    std::stringstream ss(input);
    ss >> t;

    return !(ss.fail() || !(ss >> std::ws).eof());
}

int main(void)
{
    int i;

    if (!parse_type(i))
    {
        std::cout << "Not valid!" << std::endl;
    }
    else
    {
        // ...
    }
}

Esto le permite analizar otros tipos con comprobación de errores.

---

Si está de acuerdo con las excepciones, usando lexical_cast (ya sea desde boost o "falso", vea la otra pregunta vinculada en el código [igual que el enlace anterior]), su código se parece a esto:

#include <iostream>
#include <sstream>
#include <string>

/* Faked lexical-cast from question:
https://stackoverflow.com/questions/1243428/convert-string-to-int-with-bool-fail-in-c/
*/
template <typename T>
T lexical_cast(const std::string& s)
{
    std::stringstream ss(s);

    T result;
    if ((ss >> result).fail() || !(ss >> std::ws).eof())
    {
        throw std::bad_cast("Bad cast.");
    }

    return result;
}


template <typename T>
T parse_type(void)
{
    std::string input;
    std::getline(std::cin, input);

    return lexical_cast<T>(input);
}

int main(void)
{
    try
    {
        int i = parse_type<int>();
        float f = parse_type<float>();
    }
    catch (const std::exception& e)
    {
        std::cout << e.what() << std::endl;
    }
}

No creo que boost tenga una versión sin lanzamiento del elenco léxico, por lo que podemos hacer una versión verdadera / falsa en lugar de una excepción de este código capturando bad_cast , de la siguiente manera. Una vez más, esto funciona con boost o con un elenco léxico personalizado. (Cualquier cosa que haga un reparto léxico y arroje bad_cast ):

#include <iostream>
#include <sstream>
#include <string>

/* Faked lexical-cast from question:
https://stackoverflow.com/questions/1243428/convert-string-to-int-with-bool-fail-in-c/
*/
template <typename T>
T lexical_cast(const std::string& s)
{
    std::stringstream ss(s);

    T result;
    if ((ss >> result).fail() || !(ss >> std::ws).eof())
    {
        throw std::bad_cast("Bad cast.");
    }

    return result;
}


template <typename T>
bool parse_type(T& t)
{
    std::string input;
    std::getline(std::cin, input);

    try
    {
        t = lexical_cast<T>(input);

        return true;
    }
    catch (const std::bad_cast& e)
    {
        return false;
    }
}

int main(void)
{
    int i;
    if (!parse_type(i))
    {
        std::cout << "Bad cast." << std::endl;
    }
}

Ahora vuelve a un resultado bool , excepto que evitamos la duplicación de código mediante el uso de las funciones lexical_cast existentes.

Por supuesto, puede elegir qué método le gustaría utilizar.

Answer 2

C ++ es un lenguaje de tipo estático, lo que significa que el compilador conoce el tipo de variable en todo momento. Por lo tanto, para declarar var , debe especificar un tipo, lo que hace que la declaración if haya publicado un punto discutible. Si puede describir un poco más la tarea que está tratando de lograr, tal vez haya otra ruta para resolver su problema.

Answer 3

Eso es correcto, se necesita más información, si está buscando un equivalente de " instanceOf " operador de Java, no hay uno, a menos que use RTTI y typeid.

Answer 4

¿Quiere decir que tiene un valor de punto flotante y quiere saber si es un número entero o no?

En ese caso, intente esto:

#include <math.h>

//...

double x = 5.0;
if(round(x) == x) {
   // x has an integer value
}

O, si el valor es el resultado de algún cálculo, puede haber pequeños errores de redondeo. Entonces intente algo como esto:

double x = 4.99999999999;
if(abs(round(x) - x) < 1e-8)