online - ejercicios resueltos de cadenas en c++

¿Hay alguna forma de escribir un número grande en el código fuente de C++ con espacios para que sea más legible?

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Representando números grandes en el código fuente para facilitar la lectura? 5 respuestas
• ¿Haciendo que las constantes grandes en la fuente C sean más legibles? 8 respuestas

Imagina que tengo el código:

vector<int> temp = vector<int>(1 000 000 000);

Lo anterior no se compilará ya que el compilador se quejará de los espacios. ¿Es posible indicar a C ++ que omita esos espacios al compilar, o que el número sea más fácil de leer?

Answer 1

Como esto me recuerda a los dígitos agrupando mi primer enfoque torpe sin C ++ 14
sería

#define INTGROUPED1(a)     (a%1000)
#define INTGROUPED2(a,b)   (a%1000*1000 + b%1000)
#define INTGROUPED3(a,b,c) (a%1000*1000000 + b%1000*1000 + c%1000)
int v1 = INTGROUPED1(        123);
int v2 = INTGROUPED2(    123,123);
int v3 = INTGROUPED3( 23,123,123);

pero usaría esos trucos en un contexto privado.

Solo considera a alguien escribiendo

INTGROUPED3(1234,1234,1234); //This would be (234,234,234) without a compiler complaining

EDIT1:

Tal vez un mejor enfoque sería utilizar el operador del preprocesador ##

#define NUM_GROUPED_4ARGS(a,b,c,d) (##a##b##c##d)
int num = NUM_GROUPED_4ARGS(-2,123,456,789); //int num = (-2123456789);

Esto es más parecido a WYSIWYG pero no es inmune al mal uso. P.ej. usted podría wnat el compilador para quejarse

int num = NUM_GROUPED_4ARGS(-2,/123,456,789);  //int num = (-2/123456789); 

pero no lo hará.

Answer 2

Cuando he hecho cosas similares en plataformas sin C ++ 14 (generalmente para microprocesadores), he representado grandes números dividiéndolos con la multiplicación:

int i = (1000 * 1000 * 1000);

_{^{Agregue UL o L al gusto}}

La ventaja aquí es que es compatible con prácticamente cualquier plataforma que admita C89 (y probablemente antes).

En general, es probable que sea seguro asumir que los operadores de multiplicación se caerán en el momento de la compilación, pero si está usando constantes como esta en un bucle, podría valer la pena una doble verificación.

Answer 3

Intente separador de dígitos:

int i = 1''000''000''000;

Esta característica se introduce desde C ++ 14 . Utiliza comillas simples ( '' ) como separador de dígitos.

Ver también:

• ¿Por qué no se eligió el carácter de espacio para los separadores de 14 dígitos de C ++?
• Generalización de la sobrecarga para C ++ 2000 (broma de abril del propio padre de C ++)

Answer 4

Otra idea podría ser:

#define _000 *1000

int k = 1 _000 _000;

Answer 5

Por lo general, # defino constantes para este propósito, ya que guarda los ceros de conteo y deja muy claro lo que quiere decir para cualquier persona que vea el código. Por ejemplo

#define THOUSAND 1000
#define MILLION 1000000

vector<int> temp = vector<int>(THOUSAND * MILLION);

Esto deja en claro que realmente me refiero a mil millones y no contemplé mal los ceros

Obviamente puedes usar enumeraciones si lo prefieres.

Answer 6

Si no usa C ++ 14, otra opción sería usar algún tipo de clase heredada de cadena con un int-cast implícito y tal vez una expresión regular en el constructor para restringir los números. Yo uso CString para un ejemplo fácil.

class NumString : public CString
{
public:
    NumString(CString number) : num(number) { } //maybe insert some regex-check here
    operator long() const
    {
        CString tmp = num;
        tmp.Remove('' '');        
        return atol(tmp);
    }
private:
    CString num;
};


NumString a = "1 000 000 000";
int b = a;
bool test = b == 1000000000;
//test will be true