How To Convert Float To String In C

Converting float values into string data types while working with float values in the C programming language for a variety of reasons.

Accurate conversion of float to string is a vital process in many applications, whether it’s for displaying numbers in a user-friendly manner, saving them in a database or file, or sending them as arguments to functions that need string data types.

It is essential to understand the available techniques and recommended procedures for converting float to string in C.

Why Convert Float to String In C

Here are the reasons why this conversion is needed:

• User-friendly: For applications, like financial, and scientific computations, it is critical to show float numbers in a clear and understandable manner.
• Converting float values to strings is required for correct storage and retrieval of the data when storing float values in a database 
• Calculations: In applications, like web development, float values may occasionally be represented as strings. In certain circumstances, string conversion is necessary for accurate calculation and data presentation.
• Functions that only take string data types as inputs might not accept float values as parameters.
• Handling: Large or small float values may occasionally be challenging to display or store correctly. 

Various Approaches Of Converting Float to String in C

• Using sprintf()
• Using gcvt()
• Using snprintf()

Approach 1: Using sprintf() Method

With the sprintf() function from the C standard library, float values may be formatted into strings. Its first input is a formatted string, and its second is the float value that has to be converted.

Code:

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

int main() {
  float f = (float)rand() / RAND_MAX;
  char buffer[20];
  sprintf(buffer, "%.4f", f);
  printf("Float value: %f\n", f);
  printf("String value: %s\n", buffer);
  f = -f;
  sprintf(buffer, "%.2f", f);
  printf("Float value: %f\n", f);
  printf("String value: %s\n", buffer);
  f = 0.0f;
  sprintf(buffer, "%.2f", f);
  printf("Float value: %f\n", f);
  printf("String value: %s\n", buffer);
  return 0;
}

Output:

Float value: 0.249345
String value: 0.2493
Float value: -0.249345
String value: -0.25
Float value: 0.000000
String value: 0.00

Explanation:

• The main() function begins by generating a random float number between 0 and 1 using rand() and RAND_MAX.
• It then converts this float value to a string with four decimal places using sprintf(), which stores the string in the buffer variable.
• The float value and the corresponding string value are then printed to the console using printf().
• The main() function repeats this process two more times, with slight variations in the float values generated and the number of decimal places in the resulting string values. Finally, the function returns 0 to indicate successful completion.

Approach 2: Using gcvt() Method

Using the C library function gcvt(), float values may be formatted as strings. The float value to be converted and the number of significant digits to be included in the result are its two required parameters.

Code:

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

int main() {
  double d = 123.456789;
  char buffer[20];
  gcvt(d, 6, buffer);
  printf("Double value: %f\n", d);
  printf("String value: %s\n", buffer);
  d = -d;
  gcvt(d, 4, buffer);
  printf("Double value: %f\n", d);
  printf("String value: %s\n", buffer);
  d = 0.0;
  gcvt(d, 3, buffer);
  printf("Double value: %f\n", d);
  printf("String value: %s\n", buffer);
  return 0;
}

Output:

Double value: 123.456789
String value: 123.456790
Double value: -123.456789
String value: -123.4568
Double value: 0.000000
String value: 0.00

Explanation:

• The main() function begins by assigning a double value to d.
• The gcvt() function is then used to convert this double value to a string representation with a specified number of significant digits, which is stored in the buffer array.
• The double value and its corresponding string representation are then printed to the console using printf().
• The main() function repeats this process two more times, with variations in the double values assigned and the number of significant digits specified for the string representations. Finally, the function returns 0 to indicate successful completion.

Approach 3: Using snprintf() Method

To convert float data to string format, utilise the C library function snprintf(). The sprintf() takes an extra parameter that determines the size of the character array that will hold the result. By doing this, buffer overflows are avoided.

Code:

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

int main() {
 float f = 42.0;
 char str[20];
 int size = snprintf(str, 20, "%.3f", f);
 printf("The float value is %f\n", f);
 printf("The string value is %s\n", str);
 printf("The size of the string is %d\n", size);

 f = -1.234567;
 size = snprintf(str, 20, "%+.2f", f);
 printf("The float value is %f\n", f);
 printf("The string value is %s\n", str);
 printf("The size of the string is %d\n", size);

 f = 1234567.8912345;
 size = snprintf(str, 20, "%e", f);
 printf("The float value is %f\n", f);
 printf("The string value is %s\n", str);
 printf("The size of the string is %d\n", size);

 return 0;
}

Output:

The float value is 42.000000
The string value is 42.000
The size of the string is 6
The float value is -1.234567
The string value is -1.23
The size of the string is 5
The float value is 1234567.875000
The string value is 1.234568e+06
The size of the string is 12

Explanation:

• The main() function begins by assigning a floating-point value to f. The snprintf() function is then used to convert this value to a string representation with a specified format and maximum length, which is stored in the str array.
• The function returns the number of characters written to the string, which is stored in the size variable.
• The original value and its corresponding string representation are then printed to the console using printf().
• The main() function repeats this process two more times, with variations in the floating-point values assigned and the format specifiers specified for the string representations. Finally, the function returns 0 to indicate successful completion.

Best Approach:

Best approach is sprintf() method and here are reasons why:

• The well-known and often used function sprintf() can be found in the majority of C standard libraries.
• Numerous formatting options are available, including how many decimal places a float should have.
• Additionally, it offers more output format flexibility, allowing you to select the minimum field width and include leading zeros.
• sprintf() is a suitable option in many circumstances since it offers a strong and flexible way to convert a float to a string in C.

Sample Problems:

Sample Problem 1:

You are building a scientific application that requires you to display measurements in a readable format. How would you convert float values to string format in the C programming language?

Solution:

• The code creates a class called “Measurement” to handle conversions.
• The “Measurement” class has a constructor that takes a float value and a character array to represent the unit.
• The “Measurement” class has a “toString” method that converts the float value to a string with a specified format.
• The “toString” method uses the “sprintf” function to format the float value and unit into a string.
• The “sprintf” function takes a string format and a list of arguments and writes the formatted string to a buffer.
• The “main” function creates a “Measurement” object with a float value of 12.345 and the unit “meters”.
• The “main” function calls the “toString” method of the “Measurement” object to convert the float value to a string.
• The “toString” method returns the formatted string.
• The “main” function uses the “printf” function to print the formatted string to the console. The formatted string is “12.35 meters”, because the “%0.2f” format specifies two decimal places for the float value.

Code:

#include <stdio.h>
#include <string.h>

// Create a struct to handle measurements
typedef struct {
   float value;
   char unit[10];
} Measurement;

// Convert the float value to a string with specified format
void toString(Measurement m, char* str) {
   sprintf(str, "%.2f %s", m.value, m.unit);
}

int main() {
   // Create a Measurement struct with a float value and unit
   Measurement m = {12.345, "meters"};

   // Convert the value to a string and print it
   char str[20];
   toString(m, str);
   printf("%s\n", str);

   return 0;
}

Output:

12.35 meters

Sample Problem 2:

You need to store float values in a database that only accepts string data types. How would you convert float values to string format in the C programming language?

Solution:

• The code also defines a Database class that stores floating-point values as strings in an array.
• The gcvt() function from stdlib.h is used to convert the floating-point value to a string.
• The MAX_STR_LEN macro defines the maximum length of each string in the database.
• The char* data[MAX_STR_LEN] creates an array of character pointers that can store MAX_STR_LEN strings.
• The storeData() function stores the given floating-point value as a string in the database at the given index.
• The printData() function prints the contents of the database.
• The main() function creates an instance of the Database class, stores a list of floating-point values in it, and then prints the contents of the database.

Code

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


#define MAX_STR_LEN 50


struct Database {
   char* data[MAX_STR_LEN];
};


void initDatabase(struct Database* db) {
   for (int i = 0; i < MAX_STR_LEN; i++) {
       db->data[i] = (char*)malloc(sizeof(char) * MAX_STR_LEN);
   }
}


void storeData(struct Database* db, float val, int index) {
   char* str_val = gcvt(val, 10, db->data[index]);
   printf("Storing %f as string: %s\n", val, str_val);
}


void printData(struct Database* db) {
   printf("Database contents:\n");
   for (int i = 0; i < MAX_STR_LEN; i++) {
       printf("%s\n", db->data[i]);
   }
}


int main() {
   struct Database db;
   initDatabase(&db);

   float values[] = {1.23, 4.56, 7.89, 12.34, 56.78, 90.12};
   int num_values = sizeof(values) / sizeof(float);

   for (int i = 0; i < num_values; i++) {
       storeData(&db, values[i], i);
   }

   printData(&db);

   return 0;
}

Output:

Storing 1.230000 as string: 1.230000
Storing 4.560000 as string: 4.560000
Storing 7.890000 as string: 7.890000
Storing 12.340000 as string: 12.340000
Storing 56.780000 as string: 56.780000
Storing 90.120000 as string: 90.120000
Database contents:
1.230000
4.560000
7.890000
12.340000
56.780000
90.120000

Sample Problem 3:

You are building an application that performs complex calculations on float values, and you need to pass those values as arguments to functions that expect string data types. How would you convert float values to string format in the C programming language?

Solution:

• A macro is defined using #define, which sets the maximum length of a string to 50 characters.
• The main() function is declared and defined, which is the starting point of execution.
• A float variable f is initialised with a value of 123.456789.
• A character array variable str is declared, which can store up to 50 characters.
• The float value f is converted to a string using the snprintf() function and stored in the str variable.
• Multiple float variables are declared and initialised with some values.
• A character array variable output is declared, which can store up to 50 characters. The multiple float values are concatenated into a string using the snprintf() function and stored in the output variable.

Code:

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

#define MAX_STRING_LENGTH 50

int main() {
   float f = 123.456789;
   char str[MAX_STRING_LENGTH];
  
   // convert float to string using snprintf()
   snprintf(str, MAX_STRING_LENGTH, "%f", f);
  
   printf("Float: %f\n", f);
   printf("String: %s\n", str);
  
   // multiple outputs
   float x = 1.23, y = 4.56, z = 7.89;
   char output[MAX_STRING_LENGTH];
  
   // concatenate multiple float values into a string
   snprintf(output, MAX_STRING_LENGTH, "%f, %f, %f", x, y, z);
  
   printf("Multiple outputs: %s\n", output);
  
   // negative number
   float neg_num = -12.34;
   char neg_str[MAX_STRING_LENGTH];
  
   // convert negative float to string
   snprintf(neg_str, MAX_STRING_LENGTH, "%f", neg_num);
  
   printf("Negative number: %s\n", neg_str);
  
   return 0;
}

Output:

Float: 123.456787
String: 123.456787
Multiple outputs: 1.230000, 4.560000, 7.890000
Negative number: -12.340000

Conclusion:

In conclusion, the act of converting a float to a string is essential in C programming. This work can be completed using a variety of techniques, including sprintf(), gcvt(), and snprintf(). However, because of its adaptability and better control over output formatting, sprintf() is the most common and extensively used approach. Experts in C programming advise using sprintf() to convert floats to strings.

24×7 Live C++ Homework Help From Expert Tutors! Get Help Now

Author:

Karthi Mohan