#include <stdio.h>
#include <stdlib.h>

int i2a(char *s, int n){
    div_t qr;
    int pos;

    if(n == 0) return 0;

    qr = div(n, 10);
    pos = i2a(s, qr.quot);
    s[pos] = qr.rem + '0';
    return pos + 1;
}

char* my_itoa(char *output_buff, int num){
    char *p = output_buff;
    if(num < 0){
        *p++ = '-';
        num *= -1;
    } else if(num == 0)
        *p++ = '0';
    p[i2a(p, num)]='\0';
    return output_buff;
}

int main(void){
    int number = -254;
    char string[12];
    printf("%s", my_itoa(string, number));
    return 0;
}

Use the strtoXXX() family of functions. If you need int, long or long long or their unsigned variants:

long l = strtol("1234567", NULL, 10);
long long ll = strtoll("1234567", NULL, 10);
unsigned long l = strtoul("1234567", NULL, 10);

If you need a float, double, or long double use this:

float f = strtof("3.1415927", NULL);
double d = strtod("3.1415927", NULL);

Manuals here and here.

Hmm... I can't reproduce this:

using System;

class Test
{
    static void Main()        
    {
        decimal d = decimal.Parse("1200.00");
        Console.WriteLine(d); // Prints 1200.00
    }
}

Are you sure it's not some other part of your code normalizing the decimal value later?

Just in case it's cultural issues, try this version which shouldn't depend on your locale at all:

using System;
using System.Globalization;

class Test
{
    static void Main()        
    {
        decimal d = decimal.Parse("1200.00", CultureInfo.InvariantCulture);
        Console.WriteLine(d.ToString(CultureInfo.InvariantCulture));
    }
}

• The cardinal sin

  An assignment tmp_string[tmp_string_i] = remainder; may write beyond an allocated memory. Consider a case of buffer_size being equal to 0. You must test tmp_string_i before the assignment. I don't know what exactly someone had in mind, but you are definitely committing one.

• Unnecessary variables

  decimal_number is passed by value; you can mutilate it as much as you want. There is no need to have dividend.

  Reversal can be done in-place. There is no need for tmp_string at all. tmp_string_i shall also be gone.

• Finding digits

  Executing division dividend / base twice per iteration looks wrong; special-case of the last digit looks also wrong. Using do-while solves both wrongs:

      do {
          output[output_i++] = int_to_char(dividend % base);
          number = number / base;
      } while (number != 0);
  

• No raw loops

  Most loops represent an important algorithm, which deserves to be factored out in a function of its own, for further reuse and for giving it a name. In your case, the loop under the //copy tmp_string to output in reverse order comment implements an algorithm known as reverse.

All that said, this is

• Misc

  • The returned string should be terminated by '\0', or its actual length be returned.

  • The code happily converts numbers to a base up to 36 (10 digits and 26 letters). I see no reason to limit a base to 26.

  • Return codes 0,-1,-2 should be defined as named constants.

  • Size variables (e.g. buffer_size) should be unsigned, or better yet of type size_t.

  • The decimal_number parameter is not decimal. It is just number. Need to be renamed accordingly.

#include <stdio.h>

int main() {
    unsigned f = 65535; // initial value

    // this will do the printf and ff >>= 8 until f <= 0 ( =0 actually)
    do {
      printf("%c", f & 0xff); // print once char. The &0xff keeps only the bits for one byte (8 bits)
      f >>= 8; // shifts f right side for 8 bits
    } while (f > 0);
}

Consider the value 65535, or 0xffff in hexadecimal, meaning its positive value takes 2 bytes that are 0xff and 0xff

• print of f & 0xff keeps only the 8 LSb, (0xffff & 0xff = 0xff)
• f >> = 8 shifts the value 8 bits to the right, 0xffff becomes 0x00ff (the 'ff' right side are gone
• f > 0 is true since f == 0xff now

Next loop is the same, but f >>= 8 shifts 0x00ff to the right => 0x0000, and f is null. Thus the f > 0 condition is wrong and the loop ends.

You can use this function instead of atoi:

char a3toc(const char *ptr)
{
    return (ptr[0]-'0')*100 + (ptr[1]-'0')*10 + (ptr[0]-'0');
}

So, a3toc("102") will return the same thing as (char) 102, which is an 'f'.

If you don't see why, substitute in the values: ptr[0] is '1', so the first part becomes ('1'-'0')*100 or 1*100 or 100, which is what that first 1 in 102 represents.

You can use sprintf to do it, or maybe snprintf if you have it:

char str[ENOUGH];
sprintf(str, "%d", 42);

Where the number of characters (plus terminating char) in the str can be calculated using:

(int)((ceil(log10(num))+1)*sizeof(char))

You can use the decimal.ToString override to specify a formatting.

decimal amount = 120.5m;
string str = amount.ToString("0.00");

This can also be used when using String.Format.

Console.WriteLine("{0:0.00}", amount); 

In the case of your first and second rule, it cannot be done on one line.

decimal amount = 120.5m;
string str = amount.ToString("0.00").Replace(".00", String.Empty);