There is a standard C function called modf(). You give modf() a double, and it calculates the integer part and the fraction part of the number. For example, if you give it 3.14, 3 is the integer part and 0.14 is the fractional part.
You, as the caller of modf(), want both parts. However, a C function can only return one value. How can modf() give you both pieces of information?
When you call modf(), you will supply an address where it can stash one of the numbers. In particular, it will return the fractional part and copy the integer part to the address you supply. Create a new project: a C Command Line Tool named PBR.
Edit main.c:
#include <stdio.h>
#include <math.h>
int main(int argc, const char * argv[])
{
double pi = 3.14;
double integerPart;
double fractionPart;
// Pass the address of integerPart as an argument
fractionPart = modf(pi, &integerPart);
// Find the value stored in integerPart
printf("integerPart = %.0f, fractionPart = %.2fn", integerPart, fractionPart);
return 0;
}
This is known as pass-by-reference. That is, you supply an address (also known as “a reference”), and the function puts the data there.
Here is another way to think about pass-by-reference. Imagine that you give out assignments to spies. You might tell one, “I need photos of the finance minister with his girlfriend. I’ve left a short length of steel pipe at the foot of the angel statue in the park. When you get the photos, roll them up and leave them in the pipe. I’ll pick them up Tuesday after lunch.” In the spy biz, this is known as a “dead drop.”
modf() works just like a dead drop. You are asking it to execute and telling it a location where the result can be placed so you can find it later. The only difference is that instead of a steel pipe, you are giving it a location in memory where the result can be placed.
The world is just awesome. The variety of cultures and peoples around the world inspires a great deal of excellent output from the arts and sciences.
One complication of this diversity is that different people use different units for measuring the world around them. The scientific and engineering communities tend to have a preference for metric units (such as meters) over imperial units (such as feet and inches), due to their ease of use in mathematical calculation.
If you were to write an application for consumption by users in certain parts of the world, however, you might want to be able to print the results of your meter-based calculations using feet and inches.
How would you write a function that converts a distance in meters to the equivalent distance in feet and inches? It would need to read a floating-point number and return two others. The declaration of such a function would look like this:
void metersToFeetAndInches(double meters, unsigned int *ftPtr, double *inPtr);
When the function is called, it will be passed a value for meters. It will also be supplied with locations where the values for feet and inches can be stored.
Now write the function near the top of your main.c file and call it from main():
#include <stdio.h>
#include <math.h>
void metersToFeetAndInches(double meters, unsigned int *ftPtr, double *inPtr)
{
// This function assumes meters is non-negative.
// Convert the number of meters into a floating-point number of feet
double rawFeet = meters * 3.281; // e.g. 2.4536
// How many complete feet as an unsigned int?
unsigned int feet = (unsigned int)floor(rawFeet);
// Store the number of feet at the supplied address
printf("Storing %u to the address %pn", feet, ftPtr);
*ftPtr = feet;
// Calculate inches
double fractionalFoot = rawFeet - feet;
double inches = fractionalFoot * 12.0;
// Store the number of inches at the supplied address
printf("Storing %.2f to the address %pn", inches, inPtr);
*inPtr = inches;
}
int main(int argc, const char * argv[])
{
double meters = 3.0;
unsigned int feet;
double inches;
metersToFeetAndInches(meters, &feet, &inches);
printf("%.1f meters is equal to %d feet and %.1f inches.", meters, feet, inches);
return 0;
}
Build and run the program.
