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’s 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.
There are two popular ways to describe the location of a point in 2-dimensional space: Cartesian coordinates and polar coordinates. In Cartesian coordinates, (x, y) indicates that you should go to the right x and then up y. In polar coordinates, (theta, radius) indicates that you should turn to the left by theta radians and go forward radius.
What if you wanted to write a function that converted a point in Cartesian coordinates to polar coordinates? It would need to read two floating point numbers and return two floating point numbers. The declaration of the function would look like this:
void cartesianToPolar(float x, float y, float *rPtr, float *thetaPtr)
That is, when the function is called, it will be passed values for x and y. It will also be supplied with locations where the values for radius and theta 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 cartesianToPolar(float x, float y, double *rPtr, double *thetaPtr)
{
// Store the radius in the supplied address
*rPtr = sqrt(x * x + y * y);
// Calculate theta
float theta;
if (x == 0.0) {
if (y == 0.0) {
theta = 0.0; // technically considered undefined
} else if (y > 0) {
theta = M_PI_2;
} else {
theta = - M_PI_2;
}
} else {
theta = atan(y/x);
}
// Store theta in the supplied address
*thetaPtr = theta;
}
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);
double x = 3.0;
double y = 4.0;
double radius;
double angle;
cartesianToPolar(x, y, &angle, &radius);
printf("(%.2f, %.2f) becomes (%.2f radians, %.2f)n", x, y, radius, angle);
return 0;
}Build and run the program.
