# 5.3. Composition¶

As you should expect by now, once you define a new function, you can use it as part of an expression, and you can build new functions using existing functions. For example, what if someone gave you two points, the center of the circle and a point on the perimeter, and asked for the area of the circle?

Let’s say the center point is stored in the variables `xc`

and `yc`

, and the
perimeter point is in `xp`

and `yp`

. The first step is to find the radius of
the circle, which is the distance between the two points. Fortunately,
we have a function, `distance`

, that does that.

```
double radius = distance (xc, yc, xp, yp);
```

The second step is to find the area of a circle with that radius, and return it.

```
double result = area (radius);
return result;
```

Wrapping that all up in a function, we get:

```
double fred (double xc, double yc, double xp, double yp) {
double radius = distance (xc, yc, xp, yp);
double result = area (radius);
return result;
}
```

The name of this function is `fred`

, which may seem odd. I will explain
why in the next section.

The temporary variables radius and area are useful for development and debugging, but once the program is working we can make it more concise by composing the function calls:

```
double fred (double xc, double yc, double xp, double yp) {
return area (distance (xc, yc, xp, yp));
}
```

This program shows you how the distance and area functions are composed in the fred function to calculate the area of a circle if we only know the coordinates of the center, and one other point of the circle.

- the types and quantities of variables that make up the function
- This would tell us what variables the function is composed of, but this is not what function composition means.
- the process of combining one or more functions into more complicated ones
- This is what we did inside of the fred function.
- the process of creating a function using incremental development
- Incremental development is useful in function composition, but does not define it.
- all of the above
- There is only one correct answer here!

Q-2: What is function composition?

- print_hello_name
- This function name isn't much of a change from our original, and would be a good choice, but what about the other options?
- fluffy_cat
- Although unconventional, there is nothing wrong about this name, but what about eat_pizza?
- eat_pizza
- Although unconventional, there is nothing wrong about this name, but what about fluffy_cat?
- all of the above
- All of these function names are technically legal, but in general, it's good practice to name your functions something that describes what they do.
- none of the above
- There's nothing wrong with any of these function names, although some of them are weird.

Q-3: It turns out you already have a function called `printHelloName`

so you must rename this one. Which of the following could be the
new name for your function?

```
void printHelloName (string name) {
cout << "Hello " << name << "!" << endl;
}
```

Function composition is not limited to a fixed number of calls. Multiple calls can be made to the same function as well as to a number of different functions.

This program shows how mutliple calls are made to one function and it also shows that calling two or more different functions is valid.