c++ - Problemas en la compilación de código debido al operador de módulo




c++11 (2)

Solo se puede usar % con enteros, y pow produce números de punto flotante.

Podría escribir una función de potencia de entero, o usar una tabla predefinida, pero es más sencillo invertir el orden de construcción y comenzar con el dígito más a la derecha:

int main()
{
   int arrx[4];    //stores the individual digits of number as array
   int digx = 4;   //total number of digits in number
   long int dupx = 1234;  //number which has to be stored in array
   for(int i = 0; i < digx; i++)
   {
        arrx[digx-i-1] = dupx%10;
        dupx = dupx/10;
   }
    return 0;
}

He escrito un programa para almacenar un número (que es predefinido por el programador) en forma de dígitos en una matriz.

Por ejemplo, si quiero almacenar un número 1234 en la matriz arrx [4], sus elementos serían:

arr[0] = 1
arr[1] = 2
arr[2] = 3
arr[3] = 4

Intento lograr esto usando el siguiente código:

#include <iostream>
#include <math.h>

using namespace std;

int main()
{
    int arrx[4];    // Stores the individual digits of number as array
    int digx = 4;   // Total number of digits in number
    int i;
    long int dupx = 1234;  // Number which has to be stored in array
    for(i = digx-1; i >= 0 ; i--)
    {
        arrx[digx-i-1] = int(dupx/pow(10,i));
        dupx = dupx%(pow(10, i));
    }
    return 0;
}

Sin embargo, cuando intento compilar el código anterior, aparece el siguiente mensaje de error:

error: operandos no válidos de los tipos 'long int' y 'double' a binary 'operator%'

La única conclusión que pude sacar del error anterior fue que el problema está en el operador de módulo.

Por lo tanto, tengo las siguientes preguntas en mi mente

  1. ¿Cuál es exactamente el problema con el código que contiene el operador de módulo?

  2. ¿Cómo puedo arreglar esto?

Estoy usando Code :: Blocks versión 17.12 con GNU GCC como mi compilador.


std::pow en sus diversas formas devuelve un tipo de punto flotante, incluso si los argumentos son tipos integrales.

Como % requiere argumentos integrales, la compilación fallará.

Usar (long)(pow(10,i)) es una solución, por supuesto, comprobando que (long) es lo suficientemente largo. Sin embargo, tenga en cuenta que incluso bajo IEEE754 pow no es necesario devolver el mejor valor de punto flotante posible, por lo que el truncamiento a long puede ser perjudicial en ocasiones; quizás std::round seguido por el elenco a long es preferible. Aunque la moda actual es considerar cualquier implementación de poder que se rompa para que los argumentos integrales sean defectuosos.

En tu caso, aunque estaría tentado de definir.

constexpr/*use const on earlier standards*/ int powers[] = {1, 10, 100, 1000};

e indexar adecuadamente.





c++11