The key to managing this is to clearly define the interactions among those parts. The first and most important step is to distinguish between the interface to a part and its implementation. At the language level, C++ represents interfaces by declarations. A declaration specifies all that’s needed to use a function or a type. For example:
double sqrt(double); // a square root function that takes arguments of type double and returns a variable of type double
// Declaring a class with all the necessary methods and class members
class Vector
{
public:
Vector(int s);
double& operator[](int i);
int size();
private:
double∗ elem;
int sz;
};
The key point here is that the implementation of all methods and functions can be in a completely different place, in another file. Often, functions are declared in header files with the extension .h , and the implementation is performed in the source code files .cpp .
For example, the implementation of the square root function:
double sqrt(double d) // definition of sqrt()
{
// ... algorithm as found in math textbook ...
}
Also, for the Vector class, several participants will need to be implemented:
Vector::Vector(int s) // definition of the constructor
: elem{new double[s]}, sz{s} // initialization of participants
{
}
double& Vector::operator[](int i) // definition of an access operator
{
return elem[i];
}
int Vector::size() // definition method size ()
{
return sz;
}
We must define Vector’s functions, but not sqrt() because it is part of the standard library. However, that makes no real difference: a library is simply some ‘‘other code we happen to use’’ written with the same language facilities as we use.
