Int Variable with Leading Zero

How to retain leading zeros of int variables?

The concept of leading zeros is a display concept, not a numerical one. You can put an infinite number of leading zeros on a number without changing its value. Since it's not a numeric concept, it's not stored with the number.

You have to decide how many zeros you want when you convert the number to a string. You could keep that number separately if you want.

how to add zeros for integer variable

Basically you want to add padding zeros.

string format specifier has a very simple method to this.

string valueAfterpadding;
int value = 23;
valueAfterpadding = value.ToString("D4");
Console.WriteLine(valueAfterpadding );

this solve your problem. just google it.

How to deal with leading zeros when formatting an int value

You can use the 0 as format specifier. From the documentation :

Replaces the zero with the corresponding digit if one is present; otherwise, zero appears in the result string.

You can do like :

02112321.ToString("00 000 000", CultureInfo.InvariantCulture)

Edit:
As indicate by @olivier-jacot-descombes, I miss a point. The OP want format a integer from a string to a string. Example "02112321" to "02 112 321".

It's possible with a intermediate conversion, string to int to string. With the example, this done "02112321" to 02112321 to "02 112 321" :

var original = "02112321";
var toInt = int.Parse(original, CultureInfo.InvariantCulture);
var formated = toInt.ToString("00 000 000", CultureInfo.InvariantCulture)

C++ int with preceding 0 changes entire value

An integer literal that starts from 0 defines an octal integer literal. Now in C++ there are four categories of integer literals

integer-literal:
    decimal-literal integer-suffixopt
    octal-literal integer-suffixopt
    hexadecimal-literal integer-suffixopt
    binary-literal integer-suffixopt

And octal-integer literal is defined the following way

octal-literal:
    0 octal-literal
    opt octal-digit

That is it starts from 0.

Thus this octal integer literal

0110

corresponds to the following decimal number

8^2 + 8^1 

that is equal to 72.

You can be sure that 72 in octal representation is equivalent to 110 by running the following simple program

#include <iostream>
#include <iomanip>

int main() 
{
    std::cout << std::oct << 72 << std::endl;

    return 0;
}

The output is

110

Is it possible to store a leading zero in an int?

An int basically stores leading zeros. The problem that you are running into is that you are not printing the leading zeros that are there.

Another, different approach is to create a function that will accept the four int values along with a string and to then return a string with the numbers.

With this approach you have a helper function with very good cohesion, no side effects, reusable where you need something similar to be done.

For instance:

char *joinedIntString (char *pBuff, int int1, int int2, int int3, int int4)
{
    pBuff[0] = (int1 % 10) + '0';
    pBuff[1] = (int2 % 10) + '0';
    pBuff[2] = (int3 % 10) + '0';
    pBuff[3] = (int4 % 10) + '0';
    pBuff[4] = 0;                    // end of string needed.
    return pBuff;
}

Then in the place where you need to print the value you can just call the function with the arguments and the provided character buffer and then just print the character buffer.

With this approach if you have some unreasonable numbers that end up have more than one leading zero, you will get all of the zeros.

Or you may want to have a function that combines the four ints into a single int and then another function that will print the combined int with leading zeros.

int createJoinedInt (int int1, int int2, int int3, int int4)
{
    return (int1 % 10) * 1000 + (int2 % 10) * 100 + (int 3 % 10) * 10 + (int4 % 10);
}

char *joinedIntString (char *pBuff, int joinedInt)
{
    pBuff[0] = ((joinedInt / 1000) % 10) + '0';
    pBuff[1] = ((joinedInt / 100) % 10) + '0';
    pBuff[2] = ((joinedInt / 10) % 10) + '0';
    pBuff[3] = (joinedInt % 10) + '0';
    pBuff[4] = 0;                    // end of string needed.
    return pBuff;
}

Format variable as 4 digits with leading zeroes

You would use -format operator:

'{0:d4}' -f $variable

https://ss64.com/ps/syntax-f-operator.html

the above will work if your variable is an integer, if not you can cast it to integer:

'{0:d4}' -f [int]$variable

---

Related Topics