binary string to int works only sometimes - c
So I have a code that gets two integers, converts them to int[32] strings, and does more by a simulated full adder circuit(this is to implement it to an Arduino circuit).
This is the whole code:
#include<stdio.h>
int relay(int ctrl, int input, int mode) {
printf(" Relay used ");
if (mode == 0) {
if (ctrl == 1 && (input == -1 || 1)) {
return input;
}
else
return 0;
}
else if (mode == 1) {
if ((ctrl == 0 || -1) && (input == -1 || 1)) {
return input;
}
else
return 0;
}
printf("ERR ON FUNCTION relay");
return 10000;
}//Relay circuit simulation(mode 0=naturally open,mode 1=naturally closed)
int andgate(int in1, int in2) {
printf(" AND gate used (");
int relayout = relay(in1, in2, 0);
printf(")");
if (relayout <= 0)
return 0;
else if (relayout == 1)
return 1;
printf("ERR ON FUNCTION andgate");
return 10000;
}//AND Gate circuit simulation
int orgate(int in1, int in2) {
printf(" OR Gate used ");
if (in1 || in2 == 1)
return 1;
else
return 0;
printf("ERR ON FUNCTION orgate");
return 10000;
}//OR Gate circuit simulation
int nandgate(int in1, int in2) {
printf(" NAND gate used (");
if (relay(in1, relay(in2, -1, 0), 0) == -1) {
printf(")");
return 0;
}
else if (relay(in1, relay(in2, -1, 0), 0) == 0) {
printf(")");
return 1;
}
printf("ERR ON FUNCTION nandgate");
return 10000;
}//NAND Gate circuit simulation
int xorgate(int in1, int in2) {
printf(" XOR gate used (");
int orout, nandout;
orout = orgate(in1, in2);
nandout = nandgate(in1, in2);
printf(")");
return andgate(orout, nandout);
printf("ERR ON FUNCTION xorgate");
return 10000;
}//XOR Gate circuit simulation
int hout, hc;
void hadder(int in1, int in2) {
printf(" Half adder used (");
//hout,hc : hadder output
hout = xorgate(in1, in2);
hc = andgate(in1, in2);
printf(")");
}//Half adder circuit simulation
int fout, fc;
void fadder(int in1, int in2, int c) {
printf(" Full adder used (");
int hout1, hc1;//hout,hc : hadder output, fout,fc : fadder output
hadder(in1, in2);
hout1 = hout; hc1 = hc;
hout = 0; hc = 0;
hadder(hout1, c);
fout = hout;
fc = orgate(hc1, hc);
printf(")");
}//Full adder circuit simulation
int lcheck(int leanth, int check[]) {
int bincheck[2] = { 0, };
for (int i = 0; i < leanth; i++) {
if (check[i] == 0 && bincheck[0] == 0) {
bincheck[0] = 1;
bincheck[1] = i;
}
else if (check[i] == 1) {
bincheck[0] = 0;
}
}
return bincheck[1];
}
int BintoDec(int binary[], int leangth/*unused*/)
{
int decimal = 0;
int position = 0;
for (int i = 31; i >= 0; i--)
{
if (binary[i] == 1)
printf("\n%d %d", binary[i], position);
decimal += 1 << position;
position++;
}
return decimal;
}
int main() {
int input = 0, input2 = 0;
int mask;
int ahcw[32] = { 0, }, ahcw2[32] = { 0, }, pahcw[32] = { 0, }, dahcw[32] = { 0, };
int lahcw, lahcw2, ldahcw, ssum;
printf("Input Number:");
scanf_s("%d", &input);
printf("Input Number:");
scanf_s("%d", &input2);
for (int i = 31; i >= 0; i--) {
mask = 1 << i;
ahcw[i] = input & mask ? 1 : 0;
}
lahcw = lcheck(32, ahcw);
printf("\n\n%d\n\n", lahcw);
for (int i = 31; i >= 0; i--) {
mask = 1 << i;
ahcw2[i] = input2 & mask ? 1 : 0;
}
lahcw2 = lcheck(32, ahcw);
if (lahcw >= lahcw2)
ssum = lahcw;
else
ssum = lahcw2;
for (int i = 0; i < ssum + 1; i++) {
fadder(ahcw[i], ahcw2[i], pahcw[i]);
dahcw[i] = fout;
pahcw[i + 1] = fc;
}
ldahcw = lcheck(32, dahcw);
printf("%d ", ldahcw);
for (int i = 31; i >= 0; i--) { printf("%d", dahcw[i]); if (i % 8 == 0) printf(" "); }
printf("\n\n\n\n\n\n%d", BintoDec(dahcw, 33));
}
but the problem I am facing with is in the BintoDec function.
int BintoDec(int binary[], int leangth/*unused*/)
{
int decimal = 0;
int position = 0;
for (int i = 31; i >= 0; i--)
{
if (binary[i] == 1)
printf("\n%d %d", binary[i], position);
decimal += 1 << position;
position++;
}
return decimal;
}
which should output a converted binary integer which it does when I put in an int[32] string formatted to {0,0,...,1,0,0}(outputs 4), but if I put the output of the first code(dahcw), it just spits out what seems to be a random integer.
Sorry for my bad English, it's my second language.
Edit:I have put the printf statement in my BintoDec function for debugging purposes, but it pushed decimal += 1 << position; out of the if statement, braking the function.
The quick fix would be to remove the printf statement, but I do prefer #Fiddling Bits's answer for the use of unsigned ints instead of normal ints.
And this part on the relay function ctrl == 0 || -1 had to be changed to ctrl == -1 || 0, but for some reason, it still worked without the fix.
If BintoDec is your only problem, which it probably isn't as pointed out by #Govind Parmar, this should fix your problem:
#include <stdio.h>
unsigned int BintoDec(int binary[], int length)
{
unsigned int decimal = 0;
for (int i = 0; i < length; i++)
{
if(binary[i] == 1)
decimal |= (1 << (length - i - 1));
}
return decimal;
}
int main(void)
{
int binary[32] = {1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1};
unsigned int decimal;
for(int i = 0; i < 32; i++)
{
printf("%d", binary[i]);
if((i != 0) && (((i + 1) % 4) == 0) && (i != 31))
printf(", ");
}
printf("\n");
decimal = BintoDec(binary, 32);
printf("0x%08X\n", decimal);
return 0;
}
Output:
$ gcc main.c -o main.exe; ./main.exe
1101, 1110, 1010, 1101, 1011, 1110, 1110, 1111
0xDEADBEEF
I think I've figured it out!
The BintoDec function accepts strings in this manner. For instance, the number 4 is
int a[32]={0,0,...,0,0,1,0,0}, which means a[29] is 1 and every other number is 0.
But I was converting the integer to a binary string using this piece of code.
for (int i = 31; i >= 0; i--) {
mask = 1 << i;
ahcw[i] = input & mask ? 1 : 0;
}
which if it were to convert 4, it would end up with a string like this{0,0,1,0,0,...,0,0},meaning that ahcw[2] is 1 and every other number is 0.
So, I basically needed code to flip the string so that the BintoDec function could interpret the string properly.
int fdahcw[32];
for (int i = 0; i < 32; i++) {
fdahcw[31 - i] = dahcw[i];
}
Related
A variable in a for loop is changing without being supposed to change in c
Here is the code: #include <stdio.h> // printf #include <cs50.h> // get_long #include <string.h> // strlen #include <stdlib.h> // stdlib int credit_test(string input); int main(void) { string userInput; // Gets user input, and tests if input is valid bool isInvalid = false; do { userInput = get_string("Number: "); // Prompts user for input for(int i = 0, evenIndex = strlen(userInput); evenIndex > i; i++) { if(userInput[i] - 48 >= 0 && userInput[i] - 48 <= 9 && (strlen(userInput) == 15 || strlen(userInput) == 16)) // Tests if input is valod { isInvalid = false; } else { isInvalid = true; break; } } } while(isInvalid); int keyValidity = credit_test(userInput); } int credit_test(string input) { int inputLen; inputLen = strlen(input); // Even number calculation int evenArr[16]; int evenSum = 0; int evenIndex = 0; printf("Length: %i\n", inputLen); for(int i = 0; inputLen > i; i++) { int n = i * 2; evenArr[evenIndex] = input[n] * 2; if(evenArr[evenIndex] > 0) { evenArr[evenIndex] -= 96; } if(evenArr[evenIndex] > 9) // Code to split doubles { int doubleNum = evenArr[evenIndex]; evenArr[evenIndex] = 1; evenIndex++; evenArr[evenIndex] = doubleNum % 10; } evenIndex++; evenSum += evenArr[i]; printf("%i\n", evenArr[i]); printf("Length: %i\n", inputLen); } printf("Length: %i\n", inputLen); printf("Even Sum: %i\n", evenSum); // Odd number calculation int oddArr[16]; int oddSum = 0; int oddIndex = 1; for(int i = 0; 16 > i; i++) { oddArr[i] = input[oddIndex]; if(oddArr[i] > 0) { oddArr[i] -= 48; } oddSum += oddArr[i]; oddIndex += 2; printf("%i\n", oddArr[i]); } printf("Odd Sum: %i\n", oddSum); // Validity test int finalSum = evenSum + oddSum; int cardType = finalSum % 10; printf("Final Sum: %i\n", finalSum); if(cardType == 0 && (input[0] - 48) == 5) { printf("MasterCard \n"); }else if (cardType == 0 && (input[0] - 48) == 4) { printf("Visa \n"); }else if(cardType == 0 && (input[0] - 48) == 3) { printf("Amex \n"); }else { printf("Invalid \n"); } return 0; } I just cannot wrap my head around why, but if you run the code, and keep an eye on the "inputLen" variable it stays what it should be, but in the first for loop which gets the even number in the input, the inputLen stays the same, which is correct, but when the loop finishes, for some reason, the variable changes to 0? So would anyone mind to explain as to why its happening? And sorry if the code is all wonky and bad :) Thanks so much.
This part of the loop for(int i = 0; inputLen > i; i++) { int n = i * 2; evenArr[evenIndex] = input[n] * 2; //... invokes undefined behavior because the expression input[n] can access memory beyond the used array due to using the expression i * 2 as an index. For example then i is equal to inputLen - 1 then n will bi initialized by the expression 2 * ( inputLen - 1 ) and the value of the expression you are using as an index to access elements of the array input but the array does not have so many elements. Also in this code snippet if(evenArr[evenIndex] > 9) // Code to split doubles { int doubleNum = evenArr[evenIndex]; evenArr[evenIndex] = 1; evenIndex++; evenArr[evenIndex] = doubleNum % 10; } evenIndex++; the variable evenIndex can be incremented twice that again can be a reason of undefined behavior when this variable is used as an index to access elements of the array evenArr.
Is there a way to include more than one 'if' conditional for output?
I have this code below (whole code after this section). I am wanting to include more than one casse for this section of the code: for(i = 0; i < length; i++) { if(numberArray[i] == 1) { casse = 2; } if(numberArray[i] == 2) { casse = 3; } if(numberArray[i] == 1 || numberArray[i] == 2) { casse = 4; } } So far, the above prints '4' when the value '8213' is entered. This is expected since for each round of for loop the 'casse' variable gets updated, by the time it runs the last integer in the array, the value for 'casse' has undergone many replacements and the end result is the last replacement of '4'. The objective of the code is to determine which cases (casse) have been met. There can be more than one case (casse) being met, but as it stands now, it only has room for one case. #include <stdio.h> #include <math.h> int main(void) { int odo, value, casse; int i; printf("please enter a value for the odometer:\n"); scanf("%d", &odo); value = odo; casse = 0; int length = floor(log10(abs(odo))) + 1; /* count number of digits */ int c = 0; /* digit position */ int n = value; while (n != 0) { n /= 10; c++; } int numberArray[c]; c = 0; n = value; /* extract each digit */ while (n != 0) { numberArray[c] = n % 10; n /= 10; c++; } for(i = 0; i < length; i++) { printf("%d, ", numberArray[i]); } for(i = 0; i < length; i++) { if(numberArray[i] == 1) { casse = 2; } if(numberArray[i] == 2) { casse = 3; } if(numberArray[i] == 1 || numberArray[i] == 2) { casse = 4; } } printf("\n%d\n", casse); return 0; } Output: please enter a value for the odometer: 8213 3, 1, 2, 8, 4 Expected output: please enter a value for the odometer: 8213 3, 1, 2, 8, Not only '4', but also '3', '2'.
Rather than a single variable that keeps track of the last case, you want an array which keeps track of all cases. For a small number of cases, the array can be a fixed size, with the index as case number and the value in the array as the number of times that case was triggered: int cases[5] = {0}; for(i = 0; i < length; i++) { if(numberArray[i] == 1) { cases[2]++; } if(numberArray[i] == 2) { cases[3]++; } if(numberArray[i] == 1 || numberArray[i] == 2) { cases[4]++; } }
C program not running properly on raspberry pi
I'm currently designing a hemming code. This code works perfectly on my computer but when I port it over to my pi, it just does not work properly. I have no idea why and I am pretty new at C and the raspberry pi. Any help would be greatly appreciated. Below is my full code: #include <stdio.h> #include <stdbool.h> #include <math.h> #include <string.h> #include <stdlib.h> int main(void){ int bitLen, errorLoc; printf("\nLength of the data bits: "); scanf("%d", &bitLen); char binStr[ bitLen ], binStrErr[ bitLen ]; printf("Data stream without error: "); scanf("%s", &binStr); if(strlen(binStr) > bitLen || strlen(binStr) < bitLen) { printf("\nLength of data stream given does not match stated input length!"); return 0; } printf("Location of data bit that has error: "); scanf("%d", &errorLoc); if(errorLoc > bitLen) { printf("\nValue given is bigger than the input length!"); return 0; } //Number Of Check Bits Needed int rBit = 1; while (pow(2, rBit) < (bitLen + rBit + 1)) { rBit = rBit + 1; } int checkBitsArr[rBit]; int checkBitsErrArr[rBit]; //Actual size of array bitLen = bitLen + rBit; int binNum[bitLen]; int binNumErr[bitLen]; int size = sizeof(binNum) / sizeof(binNum[0]); int binNumPos = size; printf("\nData stream: "); //Flipping the error bit and storing into another string printf("\nOriginal data stream: "); for (int i = 0; i < strlen(binStr); i++){ printf("%c", binStr[i]); if(i == (strlen(binStr)) - errorLoc){ int temp = ((binStr[i] - '0') == 0) ? 1 : 0; binStrErr[i] = temp + '0'; } else{ binStrErr[i] = binStr[i]; } } printf("\nData stream with error: "); for (int i = 0; i < strlen(binStr); i++){ printf("%c", binStrErr[i]); } //Filling in the bits into two arrays: One is the correct data stream and one with error for (int i = strlen(binStr); i >= 0; i--) { binNum[binNumPos] = binStr[i] - '0'; binNumErr[binNumPos] = binStrErr[i] - '0'; binNumPos--; } printf("\n\n"); //Moving bits to left to make space int position = 1; for (int i = size - 1; i >= 0; i--) { if ((position & (position - 1)) == 0) { for (int c = 0; c <= i; c++) { binNum[c - 1] = binNum[c]; binNumErr[c - 1] = binNumErr[c]; } binNum[i] = 33; binNumErr[i] = 33; } position++; } //Settings check bits into place position = 1; int checkBitIndex = 0; for (int i = size - 1; i >= 0; i--) { //Get check bit position if ((position & (position - 1)) == 0) { int temp = 0;//number of 1s in relation to the check bit int tempErr = 0; int maxNum = (i - position) + 1; if (maxNum < 0) maxNum = maxNum + (-1 * maxNum); //first part of check while (maxNum < i) { if (binNum[maxNum] == 1) { temp++; } if (binNumErr[maxNum] == 1) { tempErr++; } maxNum++; } int startNum = (i - position) + 1; //If the start number is less than zero, make it zero if (startNum < 0) startNum = startNum + (-1 * startNum); //Skip check method. Get the next set of check values in relation to the current check bit for (int x = startNum - (position * 2); x >= 0; x = x - (position * 2)) { int k = 0; while (k < position) { if (binNum[x + k] == 1) { temp++; } if (binNumErr[x + k] == 1) { tempErr++; } k++; } } //Set the value of check bit binNum[i] = (temp % 2 == 0) ? 0 : 1; binNumErr[i] = (tempErr % 2 == 0) ? 0 : 1; //Replace the current value with the correct checkbit checkBitsArr[checkBitIndex] = binNum[i]; checkBitsErrArr[checkBitIndex] = binNumErr[i]; temp = 0; tempErr = 0; checkBitIndex++; } position++; } printf("\nSEC code: "); printf("\nOriginal data stream: "); for (int i = 0; i < size; i++) { printf("%d", binNum[i]); } printf("\nData stream with error: "); for (int i = 0; i < size; i++) { printf("%d", binNumErr[i]); } printf("\n\n"); int checkIndex = (int)pow(2, rBit - 1); printf("\n\nCheckbits of data bits without error: \n"); for (int i = checkBitIndex - 1; i >= 0; i--) { printf("C%d: %d ", checkIndex, checkBitsArr[i]); checkIndex = checkIndex/2; } checkIndex = (int)pow(2, rBit - 1); printf("\n\nCheckbits of data bits with error: \n"); for (int i = checkBitIndex - 1; i >= 0; i--) { printf("C%d: %d ", checkIndex, checkBitsErrArr[i]); checkIndex = checkIndex/2; } checkIndex = (int)pow(2, rBit - 1); int posError = 0; printf("\n\nSyndrome code: \n"); for (int i = checkBitIndex - 1; i >= 0; i--) { int x = checkBitsErrArr[i] ^ checkBitsArr[i]; if(x == 1){ posError += checkIndex; } printf("C%d: %d ", checkIndex, x); checkIndex = checkIndex/2; } printf("\n\n"); printf("\nPosition of error: %d\n\n", posError); // printf("\n\n"); return 0; } These are the inputs for the scanf: Length of the data bits: 16 Data stream without error: 0011001100110011 Location of data bit that has error: 8 Below are my results on both computer and pi: Computer result (correct): Pi result (wrong):
Looks like you have far more than just one problem, but let's just start with the first one: char binStr[ bitLen ], binStrErr[ bitLen ]; The string you are requesting next contains not just the 16 bytes you get as input, but also an additional sentinel character as the 17th character. So at this point you already had 2 buffer overflows, which you can already see nicely in the output from the Pi. The same buffer overflow also occurs in the first example, except the memory layout is different enough so that it doesn't yield visible artifacts. for (int c = 0; c <= i; c++) { binNum[c - 1] = binNum[c]; binNumErr[c - 1] = binNumErr[c]; } Here comes the next buffer overflow, respectively actually an underflow this time. You are writing to binNum[-1] which is a memory location outside of the memory binNum is pointing to. Anyway, a buffer overflow means the behavior of your program is undefined. Get used to valgrind or similar tools for checking your code for undefined with regard to such errors.
How to format number adding points between each 3 numbers [duplicate]
In C, how can I format a large number from e.g. 1123456789 to 1,123,456,789? I tried using printf("%'10d\n", 1123456789), but that doesn't work. Could you advise anything? The simpler the solution the better.
If your printf supports the ' flag (as required by POSIX 2008 printf()), you can probably do it just by setting your locale appropriately. Example: #include <stdio.h> #include <locale.h> int main(void) { setlocale(LC_NUMERIC, ""); printf("%'d\n", 1123456789); return 0; } And build & run: $ ./example 1,123,456,789 Tested on Mac OS X & Linux (Ubuntu 10.10).
You can do it recursively as follows (beware INT_MIN if you're using two's complement, you'll need extra code to manage that): void printfcomma2 (int n) { if (n < 1000) { printf ("%d", n); return; } printfcomma2 (n/1000); printf (",%03d", n%1000); } void printfcomma (int n) { if (n < 0) { printf ("-"); n = -n; } printfcomma2 (n); } A summmary: User calls printfcomma with an integer, the special case of negative numbers is handled by simply printing "-" and making the number positive (this is the bit that won't work with INT_MIN). When you enter printfcomma2, a number less than 1,000 will just print and return. Otherwise the recursion will be called on the next level up (so 1,234,567 will be called with 1,234, then 1) until a number less than 1,000 is found. Then that number will be printed and we'll walk back up the recursion tree, printing a comma and the next number as we go. There is also the more succinct version though it does unnecessary processing in checking for negative numbers at every level (not that this will matter given the limited number of recursion levels). This one is a complete program for testing: #include <stdio.h> void printfcomma (int n) { if (n < 0) { printf ("-"); printfcomma (-n); return; } if (n < 1000) { printf ("%d", n); return; } printfcomma (n/1000); printf (",%03d", n%1000); } int main (void) { int x[] = {-1234567890, -123456, -12345, -1000, -999, -1, 0, 1, 999, 1000, 12345, 123456, 1234567890}; int *px = x; while (px != &(x[sizeof(x)/sizeof(*x)])) { printf ("%-15d: ", *px); printfcomma (*px); printf ("\n"); px++; } return 0; } and the output is: -1234567890 : -1,234,567,890 -123456 : -123,456 -12345 : -12,345 -1000 : -1,000 -999 : -999 -1 : -1 0 : 0 1 : 1 999 : 999 1000 : 1,000 12345 : 12,345 123456 : 123,456 1234567890 : 1,234,567,890 An iterative solution for those who don't trust recursion (although the only problem with recursion tends to be stack space which will not be an issue here since it'll only be a few levels deep even for a 64-bit integer): void printfcomma (int n) { int n2 = 0; int scale = 1; if (n < 0) { printf ("-"); n = -n; } while (n >= 1000) { n2 = n2 + scale * (n % 1000); n /= 1000; scale *= 1000; } printf ("%d", n); while (scale != 1) { scale /= 1000; n = n2 / scale; n2 = n2 % scale; printf (",%03d", n); } } Both of these generate 2,147,483,647 for INT_MAX. All the code above is for comma-separating three-digit groups but you can use other characters as well, such as a space: void printfspace2 (int n) { if (n < 1000) { printf ("%d", n); return; } printfspace2 (n/1000); printf (" %03d", n%1000); } void printfspace (int n) { if (n < 0) { printf ("-"); n = -n; } printfspace2 (n); }
Here's a very simple implementation. This function contains no error checking, buffer sizes must be verified by the caller. It also does not work for negative numbers. Such improvements are left as an exercise for the reader. void format_commas(int n, char *out) { int c; char buf[20]; char *p; sprintf(buf, "%d", n); c = 2 - strlen(buf) % 3; for (p = buf; *p != 0; p++) { *out++ = *p; if (c == 1) { *out++ = ','; } c = (c + 1) % 3; } *--out = 0; }
Egads! I do this all the time, using gcc/g++ and glibc on linux and yes, the ' operator may be non-standard, but I like the simplicity of it. #include <stdio.h> #include <locale.h> int main() { int bignum=12345678; setlocale(LC_ALL,""); printf("Big number: %'d\n",bignum); return 0; } Gives output of: Big number: 12,345,678 Just have to remember the 'setlocale' call in there, otherwise it won't format anything.
Perhaps a locale-aware version would be interesting. #include <stdlib.h> #include <locale.h> #include <string.h> #include <limits.h> static int next_group(char const **grouping) { if ((*grouping)[1] == CHAR_MAX) return 0; if ((*grouping)[1] != '\0') ++*grouping; return **grouping; } size_t commafmt(char *buf, /* Buffer for formatted string */ int bufsize, /* Size of buffer */ long N) /* Number to convert */ { int i; int len = 1; int posn = 1; int sign = 1; char *ptr = buf + bufsize - 1; struct lconv *fmt_info = localeconv(); char const *tsep = fmt_info->thousands_sep; char const *group = fmt_info->grouping; char const *neg = fmt_info->negative_sign; size_t sep_len = strlen(tsep); size_t group_len = strlen(group); size_t neg_len = strlen(neg); int places = (int)*group; if (bufsize < 2) { ABORT: *buf = '\0'; return 0; } *ptr-- = '\0'; --bufsize; if (N < 0L) { sign = -1; N = -N; } for ( ; len <= bufsize; ++len, ++posn) { *ptr-- = (char)((N % 10L) + '0'); if (0L == (N /= 10L)) break; if (places && (0 == (posn % places))) { places = next_group(&group); for (int i=sep_len; i>0; i--) { *ptr-- = tsep[i-1]; if (++len >= bufsize) goto ABORT; } } if (len >= bufsize) goto ABORT; } if (sign < 0) { if (len >= bufsize) goto ABORT; for (int i=neg_len; i>0; i--) { *ptr-- = neg[i-1]; if (++len >= bufsize) goto ABORT; } } memmove(buf, ++ptr, len + 1); return (size_t)len; } #ifdef TEST #include <stdio.h> #define elements(x) (sizeof(x)/sizeof(x[0])) void show(long i) { char buffer[32]; commafmt(buffer, sizeof(buffer), i); printf("%s\n", buffer); commafmt(buffer, sizeof(buffer), -i); printf("%s\n", buffer); } int main() { long inputs[] = {1, 12, 123, 1234, 12345, 123456, 1234567, 12345678 }; for (int i=0; i<elements(inputs); i++) { setlocale(LC_ALL, ""); show(inputs[i]); } return 0; } #endif This does have a bug (but one I'd consider fairly minor). On two's complement hardware, it won't convert the most-negative number correctly, because it attempts to convert a negative number to its equivalent positive number with N = -N; In two's complement, the maximally negative number doesn't have a corresponding positive number, unless you promote it to a larger type. One way to get around this is by promoting the number the corresponding unsigned type (but it's is somewhat non-trivial).
Without recursion or string handling, a mathematical approach: #include <stdio.h> #include <math.h> void print_number( int n ) { int order_of_magnitude = (n == 0) ? 1 : (int)pow( 10, ((int)floor(log10(abs(n))) / 3) * 3 ) ; printf( "%d", n / order_of_magnitude ) ; for( n = abs( n ) % order_of_magnitude, order_of_magnitude /= 1000; order_of_magnitude > 0; n %= order_of_magnitude, order_of_magnitude /= 1000 ) { printf( ",%03d", abs(n / order_of_magnitude) ) ; } } Similar in principle to Pax's recursive solution, but by calculating the order of magnitude in advance, recursion is avoided (at some considerable expense perhaps). Note also that the actual character used to separate thousands is locale specific. Edit:See #Chux's comments below for improvements.
Based on #Greg Hewgill's, but takes negative numbers into account and returns the string size. size_t str_format_int_grouped(char dst[16], int num) { char src[16]; char *p_src = src; char *p_dst = dst; const char separator = ','; int num_len, commas; num_len = sprintf(src, "%d", num); if (*p_src == '-') { *p_dst++ = *p_src++; num_len--; } for (commas = 2 - num_len % 3; *p_src; commas = (commas + 1) % 3) { *p_dst++ = *p_src++; if (commas == 1) { *p_dst++ = separator; } } *--p_dst = '\0'; return (size_t)(p_dst - dst); }
Needed to do something similar myself but rather than printing directly, needed to go to a buffer. Here's what I came up with. Works backwards. unsigned int IntegerToCommaString(char *String, unsigned long long Integer) { unsigned int Digits = 0, Offset, Loop; unsigned long long Copy = Integer; do { Digits++; Copy /= 10; } while (Copy); Digits = Offset = ((Digits - 1) / 3) + Digits; String[Offset--] = '\0'; Copy = Integer; Loop = 0; do { String[Offset] = '0' + (Copy % 10); if (!Offset--) break; if (Loop++ % 3 == 2) String[Offset--] = ','; Copy /= 10; } while (1); return Digits; } Be aware that it's only designed for unsigned integers and you must ensure that the buffer is large enough.
There's no real simple way to do this in C. I would just modify an int-to-string function to do it: void format_number(int n, char * out) { int i; int digit; int out_index = 0; for (i = n; i != 0; i /= 10) { digit = i % 10; if ((out_index + 1) % 4 == 0) { out[out_index++] = ','; } out[out_index++] = digit + '0'; } out[out_index] = '\0'; // then you reverse the out string as it was converted backwards (it's easier that way). // I'll let you figure that one out. strrev(out); }
My answer does not format the result exactly like the illustration in the question, but may fulfill the actual need in some cases with a simple one-liner or macro. One can extend it to generate more thousand-groups as necessary. The result will look for example as follows: Value: 0'000'012'345 The code: printf("Value: %llu'%03lu'%03lu'%03lu\n", (value / 1000 / 1000 / 1000), (value / 1000 / 1000) % 1000, (value / 1000) % 1000, value % 1000);
#include <stdio.h> void punt(long long n){ char s[28]; int i = 27; if(n<0){n=-n; putchar('-');} do{ s[i--] = n%10 + '0'; if(!(i%4) && n>9)s[i--]='.'; n /= 10; }while(n); puts(&s[++i]); } int main(){ punt(2134567890); punt(987); punt(9876); punt(-987); punt(-9876); punt(-654321); punt(0); punt(1000000000); punt(0x7FFFFFFFFFFFFFFF); punt(0x8000000000000001); // -max + 1 ... } My solution uses a . instead of a , It is left to the reader to change this.
This is old and there are plenty of answers but the question was not "how can I write a routine to add commas" but "how can it be done in C"? The comments pointed to this direction but on my Linux system with GCC, this works for me: #include <stdio.h> #include <stdlib.h> #include <locale.h> int main() { unsetenv("LC_ALL"); setlocale(LC_NUMERIC, ""); printf("%'lld\n", 3141592653589); } When this is run, I get: $ cc -g comma.c -o comma && ./comma 3,141,592,653,589 If I unset the LC_ALL variable before running the program the unsetenv is not necessary.
Another solution, by saving the result into an int array, maximum size of 7 because the long long int type can handle numbers in the range 9,223,372,036,854,775,807 to -9,223,372,036,854,775,807. (Note it is not an unsigned value). Non-recursive printing function static void printNumber (int numbers[8], int loc, int negative) { if (negative) { printf("-"); } if (numbers[1]==-1)//one number { printf("%d ", numbers[0]); } else { printf("%d,", numbers[loc]); while(loc--) { if(loc==0) {// last number printf("%03d ", numbers[loc]); break; } else { // number in between printf("%03d,", numbers[loc]); } } } } main function call static void getNumWcommas (long long int n, int numbers[8]) { int i; int negative=0; if (n < 0) { negative = 1; n = -n; } for(i = 0; i < 7; i++) { if (n < 1000) { numbers[i] = n; numbers[i+1] = -1; break; } numbers[i] = n%1000; n/=1000; } printNumber(numbers, i, negative);// non recursive print } testing output -9223372036854775807: -9,223,372,036,854,775,807 -1234567890 : -1,234,567,890 -123456 : -123,456 -12345 : -12,345 -1000 : -1,000 -999 : -999 -1 : -1 0 : 0 1 : 1 999 : 999 1000 : 1,000 12345 : 12,345 123456 : 123,456 1234567890 : 1,234,567,890 9223372036854775807 : 9,223,372,036,854,775,807 In main() function: int numberSeparated[8]; long long int number = 1234567890LL; getNumWcommas(number, numberSeparated); If printing is all that's needed then move int numberSeparated[8]; inside the function getNumWcommas and call it this way getNumWcommas(number).
Another iterative function int p(int n) { if(n < 0) { printf("-"); n = -n; } int a[sizeof(int) * CHAR_BIT / 3] = { 0 }; int *pa = a; while(n > 0) { *++pa = n % 1000; n /= 1000; } printf("%d", *pa); while(pa > a + 1) { printf(",%03d", *--pa); } }
Here is the slimiest, size and speed efficient implementation of this kind of decimal digit formating: const char *formatNumber ( int value, char *endOfbuffer, bool plus) { int savedValue; int charCount; savedValue = value; if (unlikely (value < 0)) value = - value; *--endOfbuffer = 0; charCount = -1; do { if (unlikely (++charCount == 3)) { charCount = 0; *--endOfbuffer = ','; } *--endOfbuffer = (char) (value % 10 + '0'); } while ((value /= 10) != 0); if (unlikely (savedValue < 0)) *--endOfbuffer = '-'; else if (unlikely (plus)) *--endOfbuffer = '+'; return endOfbuffer; } Use as following: char buffer[16]; fprintf (stderr, "test : %s.", formatNumber (1234567890, buffer + 16, true)); Output: test : +1,234,567,890. Some advantages: Function taking end of string buffer because of reverse ordered formatting. Finally, where is no need in revering generated string (strrev). This function produces one string that can be used in any algo after. It not depends nor require multiple printf/sprintf calls, which is terrible slow and always context specific. Minimum number of divide operators (/, %).
Secure format_commas, with negative numbers: Because VS < 2015 doesn't implement snprintf, you need to do this #if defined(_WIN32) #define snprintf(buf,len, format,...) _snprintf_s(buf, len,len, format, __VA_ARGS__) #endif And then char* format_commas(int n, char *out) { int c; char buf[100]; char *p; char* q = out; // Backup pointer for return... if (n < 0) { *out++ = '-'; n = abs(n); } snprintf(buf, 100, "%d", n); c = 2 - strlen(buf) % 3; for (p = buf; *p != 0; p++) { *out++ = *p; if (c == 1) { *out++ = '\''; } c = (c + 1) % 3; } *--out = 0; return q; } Example usage: size_t currentSize = getCurrentRSS(); size_t peakSize = getPeakRSS(); printf("Current size: %d\n", currentSize); printf("Peak size: %d\n\n\n", peakSize); char* szcurrentSize = (char*)malloc(100 * sizeof(char)); char* szpeakSize = (char*)malloc(100 * sizeof(char)); printf("Current size (f): %s\n", format_commas((int)currentSize, szcurrentSize)); printf("Peak size (f): %s\n", format_commas((int)currentSize, szpeakSize)); free(szcurrentSize); free(szpeakSize);
A modified version of #paxdiablo solution, but using WCHAR and wsprinf: static WCHAR buffer[10]; static int pos = 0; void printfcomma(const int &n) { if (n < 0) { wsprintf(buffer + pos, TEXT("-")); pos = lstrlen(buffer); printfcomma(-n); return; } if (n < 1000) { wsprintf(buffer + pos, TEXT("%d"), n); pos = lstrlen(buffer); return; } printfcomma(n / 1000); wsprintf(buffer + pos, TEXT(",%03d"), n % 1000); pos = lstrlen(buffer); } void my_sprintf(const int &n) { pos = 0; printfcomma(n); }
I'm new in C programming. Here is my simple code. int main() { // 1223 => 1,223 int n; int a[10]; printf(" n: "); scanf_s("%d", &n); int i = 0; while (n > 0) { int temp = n % 1000; a[i] = temp; n /= 1000; i++; } for (int j = i - 1; j >= 0; j--) { if (j == 0) { printf("%d.", a[j]); } else printf("%d,",a[j]); } getch(); return 0; }
Require: <stdio.h> + <string.h>. Advantage: short, readable, based on the format of scanf-family. And assume no comma on the right of decimal point. void add_commas(char *in, char *out) { int len_in = strlen(in); int len_int = -1; /* len_int(123.4) = 3 */ for (int i = 0; i < len_in; ++i) if (in[i] == '.') len_int = i; int pos = 0; for (int i = 0; i < len_in; ++i) { if (i>0 && i<len_int && (len_int-i)%3==0) out[pos++] = ','; out[pos++] = in[i]; } out[pos] = 0; /* Append the '\0' */ } Example, to print a formatted double: #include <stdio.h> #include <string.h> #define COUNT_DIGIT_MAX 100 int main() { double sum = 30678.7414; char input[COUNT_DIGIT_MAX+1] = { 0 }, output[COUNT_DIGIT_MAX+1] = { 0 }; snprintf(input, COUNT_DIGIT_MAX, "%.2f", sum/12); add_commas(input, output); printf("%s\n", output); } Output: 2,556.56
Using C++'s std::string as return value with possibly the least overhead and not using any std library functions (sprintf, to_string, etc.). string group_digs_c(int num) { const unsigned int BUF_SIZE = 128; char buf[BUF_SIZE] = { 0 }, * pbuf = &buf[BUF_SIZE - 1]; int k = 0, neg = 0; if (num < 0) { neg = 1; num = num * -1; }; while(num) { if (k > 0 && k % 3 == 0) *pbuf-- = ','; *pbuf-- = (num % 10) + '0'; num /= 10; ++k; } if (neg) *pbuf = '-'; else ++pbuf; int cc = buf + BUF_SIZE - pbuf; memmove(buf, pbuf, cc); buf[cc] = 0; string rv = buf; return rv; }
Here is a simple portable solution relying on sprintf: #include <stdio.h> // assuming out points to an array of sufficient size char *format_commas(char *out, int n, int min_digits) { int len = sprintf(out, "%.*d", min_digits, n); int i = (*out == '-'), j = len, k = (j - i - 1) / 3; out[j + k] = '\0'; while (k-- > 0) { j -= 3; out[j + k + 3] = out[j + 2]; out[j + k + 2] = out[j + 1]; out[j + k + 1] = out[j + 0]; out[j + k + 0] = ','; } return out; } The code is easy to adapt for other integer types.
There are many interesting contributions here. Some covered all cases, some did not. I picked four of the contributions to test, found some failure cases during testing and then added a solution of my own. I tested all methods for both accuracy and speed. Even though the OP only requested a solution for one positive number, I upgraded the contributions that didn't cover all possible numbers (so the code below may be slightly different from the original postings). The cases that weren't covered include: 0, negative numbers and the minimum number (INT_MIN). I changed the declared type from "int" to "long long" since it's more general and all ints will get promoted to long long. I also standardized the call interface to include the number as well as a buffer to contain the formatted string (like some of the contributions) and returned a pointer to the buffer: char* funcName(long long number_to_format, char* string_buffer); Including a buffer parameter is considered by some to be "better" than having the function: 1) contain a static buffer (would not be re-entrant) or 2) allocate space for the buffer (would require caller to de-allocate the memory) or 3) print the result directly to stdout (would not be as generally useful since the output may be targeted for a GUI widget, file, pty, pipe, etc.). I tried to use the same function names as the original contributions to make it easier to refer back to the originals. Contributed functions were modified as needed to pass the accuracy test so that the speed test would be meaningful. The results are included here in case you would like to test more of the contributed techniques for comparison. All code and test code used to generate the results are shown below. So, here are the results: Accuracy Test (test cases: LLONG_MIN, -999, -99, 0, 99, 999, LLONG_MAX): ---------------------------------------------------- print_number: -9,223,372,036,854,775,808, -999, -99, 0, 99, 999, 9,223,372,036,854,775,807 fmtLocale: -9,223,372,036,854,775,808, -999, -99, 0, 99, 999, 9,223,372,036,854,775,807 fmtCommas: -9,223,372,036,854,775,808, -999, -99, 0, 99, 999, 9,223,372,036,854,775,807 format_number: -9,223,372,036,854,775,808, -999, -99, 0, 99, 999, 9,223,372,036,854,775,807 itoa_commas: -9,223,372,036,854,775,808, -999, -99, 0, 99, 999, 9,223,372,036,854,775,807 Speed Test: (1 million calls, values reflect average time per call) ---------------------------------------------------- print_number: 0.747 us (microsec) per call fmtLocale: 0.222 us (microsec) per call fmtCommas: 0.212 us (microsec) per call format_number: 0.124 us (microsec) per call itoa_commas: 0.085 us (microsec) per call Since all contributed techniques are fast (< 1 microsecond on my laptop), unless you need to format millions of numbers, any of the techniques should be acceptable. It's probably best to choose the technique that is most readable to you. Here is the code: #line 2 "comma.c" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> #include <math.h> #include <locale.h> #include <limits.h> // ---------------------------------------------------------- char* print_number( long long n, char buf[32] ) { long long order_of_magnitude = (n == 0) ? 1 : (long long)pow( 10, ((long long)floor(log10(fabs(n))) / 3) * 3 ) ; char *ptr = buf; sprintf(ptr, "%d", n / order_of_magnitude ) ; for( n %= order_of_magnitude, order_of_magnitude /= 1000; order_of_magnitude > 0; n %= order_of_magnitude, order_of_magnitude /= 1000 ) { ptr += strlen(ptr); sprintf(ptr, ",%03d", abs(n / order_of_magnitude) ); } return buf; } // ---------------------------------------------------------- char* fmtLocale(long long i, char buf[32]) { sprintf(buf, "%'lld", i); // requires setLocale in main return buf; } // ---------------------------------------------------------- char* fmtCommas(long long num, char dst[32]) { char src[27]; char *p_src = src; char *p_dst = dst; const char separator = ','; int num_len, commas; num_len = sprintf(src, "%lld", num); if (*p_src == '-') { *p_dst++ = *p_src++; num_len--; } for (commas = 2 - num_len % 3; *p_src; commas = (commas + 1) % 3) { *p_dst++ = *p_src++; if (commas == 1) { *p_dst++ = separator; } } *--p_dst = '\0'; return dst; } // ---------------------------------------------------------- char* format_number(long long n, char out[32]) { int digit; int out_index = 0; long long i = (n < 0) ? -n : n; if (i == LLONG_MIN) i = LLONG_MAX; // handle MIN, offset by 1 if (i == 0) { out[out_index++] = '0'; } // handle 0 for ( ; i != 0; i /= 10) { digit = i % 10; if ((out_index + 1) % 4 == 0) { out[out_index++] = ','; } out[out_index++] = digit + '0'; } if (n == LLONG_MIN) { out[0]++; } // correct for offset if (n < 0) { out[out_index++] = '-'; } out[out_index] = '\0'; // then you reverse the out string for (int i=0, j = strlen(out) - 1; i<=j; ++i, --j) { char tmp = out[i]; out[i] = out[j]; out[j] = tmp; } return out; } // ---------------------------------------------------------- char* itoa_commas(long long i, char buf[32]) { char* p = buf + 31; *p = '\0'; // terminate string if (i == 0) { *(--p) = '0'; return p; } // handle 0 long long n = (i < 0) ? -i : i; if (n == LLONG_MIN) n = LLONG_MAX; // handle MIN, offset by 1 for (int j=0; 1; ++j) { *--p = '0' + n % 10; // insert digit if ((n /= 10) <= 0) break; if (j % 3 == 2) *--p = ','; // insert a comma } if (i == LLONG_MIN) { p[24]++; } // correct for offset if (i < 0) { *--p = '-'; } return p; } // ---------------------------------------------------------- // Test Accuracy // ---------------------------------------------------------- void test_accuracy(char* name, char* (*func)(long long n, char* buf)) { char sbuf[32]; // string buffer long long nbuf[] = { LLONG_MIN, -999, -99, 0, 99, 999, LLONG_MAX }; printf("%s:\n", name); printf(" %s", func(nbuf[0], sbuf)); for (int i=1; i < sizeof(nbuf) / sizeof(long long int); ++i) { printf(", %s", func(nbuf[i], sbuf)); } printf("\n"); } // ---------------------------------------------------------- // Test Speed // ---------------------------------------------------------- void test_speed(char* name, char* (*func)(long long n, char* buf)) { int cycleCount = 1000000; //int cycleCount = 1; clock_t start; double elapsed; char sbuf[32]; // string buffer start = clock(); for (int i=0; i < cycleCount; ++i) { char* s = func(LLONG_MAX, sbuf); } elapsed = (double)(clock() - start) / (CLOCKS_PER_SEC / 1000000.0); printf("%14s: %7.3f us (microsec) per call\n", name, elapsed / cycleCount); } // ---------------------------------------------------------- int main(int argc, char* argv[]){ setlocale(LC_ALL, ""); printf("\nAccuracy Test: (LLONG_MIN, -999, 0, 99, LLONG_MAX)\n"); printf("----------------------------------------------------\n"); test_accuracy("print_number", print_number); test_accuracy("fmtLocale", fmtLocale); test_accuracy("fmtCommas", fmtCommas); test_accuracy("format_number", format_number); test_accuracy("itoa_commas", itoa_commas); printf("\nSpeed Test: 1 million calls\n\n"); printf("----------------------------------------------------\n"); test_speed("print_number", print_number); test_speed("fmtLocale", fmtLocale); test_speed("fmtCommas", fmtCommas); test_speed("format_number", format_number); test_speed("itoa_commas", itoa_commas); return 0; }
Can be done pretty easily... //Make sure output buffer is big enough and that input is a valid null terminated string void pretty_number(const char* input, char * output) { int iInputLen = strlen(input); int iOutputBufferPos = 0; for(int i = 0; i < iInputLen; i++) { if((iInputLen-i) % 3 == 0 && i != 0) { output[iOutputBufferPos++] = ','; } output[iOutputBufferPos++] = input[i]; } output[iOutputBufferPos] = '\0'; } Example call: char szBuffer[512]; pretty_number("1234567", szBuffer); //strcmp(szBuffer, "1,234,567") == 0
void printfcomma ( long long unsigned int n) { char nstring[100]; int m; int ptr; int i,j; sprintf(nstring,"%llu",n); m=strlen(nstring); ptr=m%3; if (ptr) { for (i=0;i<ptr;i++) // print first digits before comma printf("%c", nstring[i]); printf(","); } j=0; for (i=ptr;i<m;i++) // print the rest inserting commas { printf("%c",nstring[i]); j++; if (j%3==0) if(i<(m-1)) printf(","); } }
// separate thousands int digit; int idx = 0; static char buffer[32]; char* p = &buffer[32]; *--p = '\0'; for (int i = fCounter; i != 0; i /= 10) { digit = i % 10; if ((p - buffer) % 4 == 0) *--p = ' '; *--p = digit + '0'; }
Adding decimal numbers as strings in C
So I understand how to perform calculations on integers represented in strings and then printing the result in a string. But I'm lost on how to do the same thing with a decimal in the number represented in a string. Here's how I did it with integers. This part of the code is adding together two integers: int answer = 0; char str1[100]; int count = 0; int total = 0; int k = 0; int diff = 0; if (ele == ele2) { for (k = strlen(op1) - 1; k > -1; k--) { if ((strspn(operand, "+") == strlen(operand))) { answer = (op1[k] - '0') + (op2[k] - '0'); } else if ((strspn(operand, "-") == strlen(operand))) { answer = (op1[k] - '0') - (op2[k] - '0'); } total += (pow(10, count) * answer); count++; } sprintf(str1, "%d", total); printf("Answer: %s ", str1); } Output // 12 + 14 Answer: 26 // Answer given as a string Example 12.2 + 14.5 // Three strings Answer: 16.7 // Answer as string Current Attempt: for (k = strlen(argv[1]) - 1; k > -1; k--) { if (argv[1][k] == '.') { dec = k; } else { answer = (argv[1][k] - '0') + (argv[3][k] - '0'); total += (pow(10, count) * answer); count++; } } // needs to be converted to a long? // ele is the length of the operand total = total / pow(10, ele - dec); sprintf(str1, "%d", total); printf("Answer: %s ", str1);
Sharing a simple algo to begin with (and assuming your adding integer funciton works fine). A decimal number is basically two integers separated by ".". Identify the position of "." and grab the two sides of the integer as integerPart, decimalPart One caveat on getting the decimalPart is that the length of all the decimalParts should be same, if not, add "0"s in the suffix. Add the integerPart, add the decimalPart and handle the carryForwards in the decimalPart. So, 12.2 + 14.95 = (12 + 14) (20 + 95) = 26 115 = 26+1 15 = 27.15
This is a quick and dirty implementation: no parameter check, no deep test only an idea of how you should process. #include <stdio.h> #include <stdlib.h> typedef struct { int total_digits;; int decimal_points; int *number; } NUMBER, *DECIMALNUMBER; DECIMALNUMBER initilize(char *str) { DECIMALNUMBER result = calloc(1, sizeof(NUMBER)); int in_decimal = 0; char *s; int i; for (s = str; *s; s++) { if (isdigit(*s)) { result->total_digits++; if (in_decimal) { result -> decimal_points++; } } else if (*s == '.') { in_decimal = 1; } else { return NULL; } } result->number = calloc(result->decimal_points, sizeof(int)); i=0; for (s = str; *s; s++) { if (isdigit(*s)) { result->number[i++] = (int)(*s - '0'); } } // printf("result->total_digits is %d\n",result->total_digits); // printf("result->decimal_points is %d\n",result->decimal_points); // printf("result is %d\n",result->number[--i]); // printf("result is %d\n",result->number[--i]); // printf("result is %d\n",result->number[--i]); return result; } void print_number(DECIMALNUMBER p) { int i; for (i=0; i<p->total_digits; i++) { if (i==p->total_digits - p->decimal_points) { printf("."); } printf("%d", p->number[i]); } printf("\n"); } DECIMALNUMBER sum(DECIMALNUMBER a, DECIMALNUMBER b) { int max_decimals = a->decimal_points>b->decimal_points ? a->decimal_points : b->decimal_points; int max_digits_count = a->total_digits>b->total_digits ? a->total_digits : b->total_digits; DECIMALNUMBER result = calloc(1, sizeof(NUMBER)); result->total_digits = max_digits_count; result->decimal_points = max_decimals; result->number = calloc(max_digits_count, sizeof(int)); int i1 = a->total_digits-1; int i2 = b->total_digits-1; int i3 = result->total_digits-1; int remainder = 0; int summed; while (i1 >= 0 || i2 >=0) { int aa = i1 < 0 ? 0 : a->number[i1]; int bb = i2 < 0 ? 0 : b->number[i2]; summed = aa + bb + remainder; result->number[i3] = summed % 10; remainder = summed / 10; i1--; i2--; i3--; } return result; } int main() { DECIMALNUMBER a = initilize("12.2"); DECIMALNUMBER b = initilize("16.7"); print_number(a); print_number(b); DECIMALNUMBER c = sum (a,b); print_number(c); return 0; }