1 Declaring New Data Types

In the course of designing a program, we discover that we need a new data type. What are our options?

Well, to a certain degree, it depends upon whether or not we already have a data type that provides the interface (data and functions) that we want for this new one.

• On rare occasions, we may be lucky enough to have an existing type that provides exactly the capabilities we want for our new type.

In that case, we can get by just using a typedef to create an “alias” for the existing type. For example, suppose that we were writing a program to look up the zip code for any given city. Obviously, one of the kinds of data we will be manipulating will be “city names”. Now, a city name is pretty much just an ordinary character string, and anything we can do to a character string we could probably also do to a city name. So we might very well decide to take advantage of the existing C++ std::string data type and declare our new one this way:

    typedef std::string CityName;

or, a newer syntax,

    using CityName = std::string;




These basically give us a way to attach a more
convenient name to an existing type.

• We may need to build our ADT “from scratch”, specifying exactly what data and functions we want to associate with the new ADT. This is done by declaring a new class and listing the data and function members we need to achieve our desired abstraction.

For example, in building a system to track the output of a publishing company, we might write the class shown here (we’ll talk about where the data and function members come from just a bit later).

    class Book {
    public:
      std::string getTitle() const;
      void setTitle(std::string theTitle);

      std::string getISBN() const;
      void setISBN(std::string id);

      ⋮
    private:
      ⋮
    };

• In between those two extremes, we sometimes have an existing type that provides almost everything we want for our new type, but needs just a little more data or a few more functions to make it what we want. In that case we may be able to create an extended version of the existing type by using inheritance.

For example, suppose that our publishing company has a number of books that are grouped into series (e.g., “Cookbooks of the World”, volumes 1-28). This leads to the idea (abstraction) of a “book in series”, that would be identical to a regular Book except for providing two addition data items, a series title and a volume number. We might then write the declaration shown here, which creates a new type named “BookInSeries” that is identical to the existing type Book except that it carries two additional data fields and the functions that provide access to them.

```cpp
class BookInSeries: public Book {
   public:
     std::string getSeriesTitle() const;
     void setSeriesTitle(std::string theSeries);

     int getVolume() const;
     void setVolume(int);
   private:
     std::string seriesTitle;
     int volume;
};

```




Inheritance is a powerful technique that lies at the heart of
object-oriented programming. We won't use much of it in this course,
but it is covered extensively in CS 330.

2 Manipulating an ADT: Attributes and Operations

An ADT is more than just a type name. It also provides a description of what other code can do to manipulate that data.

2.1 Attributes

As you work with ADTs, it becomes very clear that many things we do to data are little more than fetching and storing smaller pieces of data that we think of as components of the ADT.

For example,

2.3 Example: the Publishing World

In the prior lesson, we used the following to illustrate our data abstraction for things related to books.

package Publishers {
object PrenticeHall
object AddisonWesley
}

package Books {

object cs361Text {
  Data Structures in C++
}

object cs390Text {
  Automata and Formal Languages
}

object cs488Text {
  Intro to Compilers
}

object classicLit {
  The Importance of being Earnest
}
  
}

package Authors {
object Weiss {
  name
  address
}
object Aho  {
  name
  address
}
object Ullman {
  name
  address
}
object Wilde {
  name
  address
}
}

PrenticeHall <---> cs361Text: publishes >
AddisonWesley <---> cs390Text: publishes >
AddisonWesley  <---> cs488Text: publishes >
AddisonWesley  <---> classicLit: publishes >

cs361Text <---> Weiss: authors
cs390Text <---> Ullman: authors
cs488Text <---> Aho: authors
cs488Text <---> Ullman: authors
classicLit <---> Wilde: authors

PrenticeHall "hasContractWith" --->  Weiss
AddisonWesley "hasContractWith" --->  Aho
AddisonWesley "hasContractWith" --->  Ullman

As we move forward into considering an ADT, we would shift our focus away from the individual objects and more towards the classes:

skinparam style strictuml


class Publisher {
    name: string;
    addAuthor(Author);
    removeAuthor(Author);
    numberOfAuthors(): int;
    getAuthor(int i): Author;
    addBook(Book);
    removeBook(Book);
    numberOfBooks(): int;
    getBook(int i): Book;
}

class Book {
    title: string;
    publisher: Publisher;
    isbn: string;
    addAuthor(Author);
    removeAuthor(Author);
    numberOfAuthors(): int;
    getAuthor(int i): Author;
}

class Author {
    name: string;
    address: Address;
    publisher: Publisher;  
    addBook(Book);
    removeBook(Book);
    numberOfBooks(): int;
    getBook(int i): Book;
}

class Address {
    street: string;
    city: string;
    state: string;
    zipCode: string;
}

Book "*" o--- "*" Author: authors
Publisher "1" --- "*" Book: publishes >
Publisher "1" --- "*" Author: has contract with >

3 Realizing the Interface in C++

Eventually, a C++ programmer must sit down to capture the abstract ideas of attributes and operations in a C++ class. At this stage, we are really only worrying about the public interface of a class. Generally this involves adding public member functions and, rarely, public data members.

Of course, C++ being what it is, there’s lots to think about even when only working on the interface.

3.1 Basic Attributes & Operations

As a first pass, we can translate the attributes and operations into C++.

For example,

skinparam style strictuml

class Address {
    street: string;
    city: string;
    state: string;
    zipCode: string;
}

class Address {
public:
  std::string getStreet() const;
  void setStreet (std::string theStreet);

  std::string getCity() const;
  void setCity (std::string theCity);

  std::string getState() const;
  void setState (std::string theState);

  std::string getZip() const;
  void setZip (std::string theZip);

private:
  ⋮
};

4.1 Constructing Books with Multiple Authors

Our Book class will need a constructor as well, but this one is slightly complicated by the fact that books can have multiple authors. How can we pass an arbitrary number of authors to a constructor (or to any function, for that matter)?

class Book {
public:
   Book(const std::string& title, 
              const std::string& isbn, 
              const Publisher& publisher,
              Author* authors = nullptr,   ➀ 
              int numAuthors = 0);         ➁

      ⋮
};

For now, we’ll do it by passing an array of Authors (➀), together with an integer indicating how many items are in the array. (In a later lesson, we will see much cleaner ways to handle this problem.)

• Remember, the data type “Author*” could denote either a pointer to a single Author value, or an array of Author objects.
• The = nullptr (➀) and = 0 (➁) define default values for their function parameters. If we write a call to this (constructor) function and supply only the first three parameters, the compiler will fill in these defaults for the missing final two parameters.

With that constructor in place, we could initialize books by first building an appropriate author array, then declaring our new Book object. For example, given these authors:

Author weiss (
    "Weiss, Mark",
    Address("21 Nowhere Dr.", "Podunk", "NY", "01010")
    );
Author doe (
    "Doe, John",
    Address("212 Baker St.", "Peoria", "IL", "12345")
    );
Author smith (
    "Smith, Jane",
    Address("47 Scenic Ct.", "Oahu", "HA", "54321")
    );

we can create some books like this:

Publisher prenticeHall = ...;
Author textAuthors[] = {weiss};
Book text361 ("Data Structures and Algorithms in C++", "013284737X",
               macmillan, 
               textAuthors, 1);

Author recipeAuthors[] = {doe, smith};
Book recipes ("Cooking with Gas", "0-124-46821", prenticeHall, 
              recipeAuthors, 2);

Taking advantage of the default parameters, we could write

Book unknownText ("Much Ado About Nothing", "123456789", prenticeHall);

In cases where we really do have multiple authors (e.g., recipes), that’s probably as simple as it’s going to get. It’s a bit awkward for books that only have a single author, however. But, just as with any other functions in C++, nothing limits us to having a single constructor function as long as the formal parameter list for each constructor is different. Since single authorship is likely to be a common case, it might be convenient to declare another Book constructor to serve that special case.

class Book {
public:
   Book(const std::string& title, 
              const std::string& isbn, 
              const Publisher& publisher,
              Author* authors = nullptr,
              int numAuthors = 0);

   Book(const std::string& title, 
              const std::string& isbn, 
              const Publisher& publisher,
              Author& author1);

      ⋮
};

We could then use either constructor, as appropriate, when creating Books.

Book text361 ("Data Structures and Algorithms in C++", "013284737X",
               macmillan, 
               weiss);

Author recipeAuthors[] = {doe, smith};
Book recipes ("Cooking with Gas", "0-124-46821", prenticeHall, 
              recipeAuthors, 2);

4.2 The Default Constructor

The default constructor is a constructor that takes no arguments. This is the constructor you are calling when you declare an object with no explicit initialization parameters. E.g.,

std::string s;

A default constructor might be declared to take no parameters at all, like this:

class Author
{
public:
  Author();

  Author (std::string theName, const Address& theAddress);

    ⋮

Or by supplying a default value for every parameter in an existing constructor:

class Address {
public:

  Address (std::string theStreet = std::string("unknown"),
           std::string theCity = std::string(),
           std::string theState = std::string(),
           std::string theZip = std::string());

    ⋮

Either way, we can call it with no parameters.

Why is this called a “default” constructor? There’s actually nothing particularly special about it. It’s just an ordinary constructor, but it is used in a special way.

Whenever we create an array of elements, the compiler implicitly calls the default constructor to initialize each element of the array.

For example, if we declared:

std::string words[5000];

then each of the 5000 elements of this array will be initialized using the default constructor for string.

In fact, if we don’t have a default constructor for our class, then we can’t create arrays containing that type of data. Attempting to do so will result in a compilation error.

Because arrays are so common, it is rare that we would actually want a class with no default constructor.

4.2.1 Compiler-Generated Constructors

It’s hard to imagine a situation in which we create a class and would deliberately prefer that, when we declare a variable of that class type, its data members should remain uninitialized.

That’s just poor programming practice.

The designers of the C++ language felt the same way. So the C++ compiler tries to be helpful:

If we create no constructors at all for a class, the compiler generates a default constructor for us.

Why does the compiler generate, specifically, a default constructor? Well, any other choice would mean that the compiler would have to figure out what data we needed to supply to initialize each data member, and what we wanted to do with that data to carry out the initialization. That’s well beyond the intelligence of any compiler, so it opts for the simple case of generating a contructor that takes no parameters at all.

That automatically generated default constructor works by initializing every data member in our class with its own default constructor. In many cases (e.g., strings), this does something entirely reasonable for our purposes.

Be careful, though: the “default constructors” for the primitive types such as int, double and pointers work by doing nothing at all — leaving us with an uninitialized value containing whatever bits happened to have been left at that particular memory address by earlier calculations/programs.

4.3 The Copy Constructor

Another specialized constructor, the copy constructor is a constructor that takes a (const reference to a) value of the same type its only parameter. For example:

Book (const Book& b);

• likethe default constructor, there is nothing unusual about the copy constructor itself.

  • It’s just an ordinary constructor.

• It’s special because of the number of common situations in which it gets used.

  • The compiler often generates implicit calls to this constructor in places where we might not expect it.

4.3.1 Where are Copy Constructors Used?

The copy constructor gets used in 5 situations:

1. When you declare a new object as a copy of an old one:

   Book book2 (book1);
   

   or

   Book book2 = book1;
   

2. When a function call passes a parameter “by copy” (i.e., the formal parameter does not have a &):

   void foo (Book b, int k);
     ⋮
   
   Book text361 (...);
   foo (text361, 0);   // foo actually gets a copy of text361
   

3. When a function returns an object:

   Book foo (int k);
   {
     Book b;
     ⋮
     return b; // a copy of b is placed in the caller's memory area
   }
   

4. When data members are initialized in a constructor’s initialization list from a single parameter of the same type:

   Author::Author (std::string theName, 
                   Address theAddress, long id)
     : name(theName), 
       address(theAddress),
       identifier(id)
   {
   }
   

   We’ll cover initialization lists in the next lesson.

5. When an object is a data member of another class for which the compiler has generated its own copy constructor.

4.3.2 Compiler-Generated Copy Constructors

As you can see from that list, the copy constructor gets used a lot. It would be very awkward to work with a class that did not provide a copy constructor.

So, again, the compiler tries to be helpful.

If we do not create a copy constructor for a class, the compiler generates one for us.

• This automatically generated version works by copying each data member via their individual copy constructors.

• For data members that are primitives, such as int or pointers, the copying is done by copying all the bits of that primitive object.

  • For things like int or double, that’s just fine.
  • But, we will see later that this may or may not be what we want for pointers.

5 Destructors

The flip-side of initializing new objects is cleaning up when old objects are going away. Just as C++ provides special functions, constructors, for handling initialization, it also provides special functions, destructors, for handling clean-up.

A destructor for the class Foo is a function of the form

~Foo();

You should never call a destructors explicitly.

Instead the compiler generates a call to an object’s destructor when

• Execution passes outside of the { ... } within which the object was declared. For example, if we wrote

  if (someTest)
    {
     Book b = text361;
     cout << b.getTitle() << endl;
    }
  
  

  what the compiler would actually generate would be something along the lines of

  if (someTest)
    {
     Book b = text361;
     cout << b.getTitle() << endl;
     b.~Book();  // implicitly generated by the compiler
    }
  

• When we delete a pointer to an object, the object’s destructor is (implicitly) called prior to actually recovering the memory occupied by the object. For example, if we were to write:

    Book *bPointer = new Book(text361); // initialized using copy constructor
       ⋮
    cout << bPointer->getTitle() << endl;
    delete bPointer;
  

  what the compiler would actually generate would be something along the lines of

    Book *bPointer = new Book(text361); // initialized using copy constructor
       ⋮
    cout << bPointer->getTitle() << endl;
    bPointer->~Book();
    free(bPointer);  // recover memory at the address in bPointer
  
  

Now, we have not declared or implemented a destructor for any of our classes, yet. That might be OK.

If you don’t provide a destructor for a class, the compiler generates one for you automatically.

6.1 Example: Date Operations

Earlier, for example, we suggested that a calendar date might have some operations like this:

We could declare those in C++ like this:

class Date {
 private:
   int daysSinceEpoch;  
 public:
   Date ();
   Date (int day, int month, int year);
   
   int getDay() const;  
   void setDay (int day);
   
   int getMonth() const;
   void setMonth(int month);
   
   int getYear() const;
   void setYear();
   
   Date dateSomeDaysAway(int numDaysAway) const;
   int numberOfDaysApart(const Date& from) const;
};

This would let us write application code like:

Date rescheduleWeeklyMeeting(const Date& meeting)
{
    Date followUp = meeting.dateSomeDaysAway(7);
    return followUp;
}

or

void warnIfBookIsOverdue (const Date& checkoutDate, const Date& today)
{
    if (today.numberOfDaysApart(checkoutDate) > 21)
    {
        cout << "This book is overdue." << endl;
    }
}

The function bodies for the two operations given as

Date Date::dateSomeDaysAway(int numDaysAway) const
{
    Date result;
    result.daysSinceEpoch = daysSinceEpoch + numDaysAway;
    return result;
}
   
int Date::numberOfDaysApart(const Date& from) const
{
    return daysSinceEpoch - from.daysSinceEpoch;
}

Now, the names of the two operations are a bit awkward, particularly the first one. Perhaps you could think of better ones. But I honestly didn’t worry about it at the time because I knew that I was eventually going to replace these by operators.

skinparam style strictuml

class Date {
    day: int;
    month: int; 
    year: int;
    operator+(numDaysAway: int): Date;
    operator-(from: Date): int;
}

All that we have done here is to change the names of the two functions, not their behavior. And that’s all that would change in the C++ class declaration:

class Date {
 private:
   int daysSinceEpoch;  
 public:
   Date ();
   Date (int day, int month, int year);
   
   int getDay() const;  
   void setDay (int day);
   
   int getMonth() const;
   void setMonth(int month);
   
   int getYear() const;
   void setYear();
   
   Date operator+(int numDaysAway) const;
   int operator-(const Date& from) const;
};

I think, however, that this makes for much nicer application code:

Date rescheduleWeeklyMeeting(const Date& meeting)
{
    Date followUp = meeting + 7;
    return followUp;
}

or

void warnIfBookIsOverdue (const Date& checkoutDate, const Date& today)
{
    if (today - checkoutDate > 21)
    {
        cout << "This book is overdue." << endl;
    }
}

For the eventual implementation, again, all that changes are the function names:

Date Date::operator+(int numDaysAway) const
{
    Date result;
    result.daysSinceEpoch = daysSinceEpoch + numDaysAway;
    return result;
}
   
int Date::operator-(const Date& from) const
{
    return daysSinceEpoch - from.daysSinceEpoch;
}

Operator functions seem to cause some students a great deal of anxiety, but they really aren’t all that complicated.

When we declare and implement them, it’s just a change to a function name that starts with “operator”.

It is only when we use them that their special nature comes out, as they provide us with a shortcut to writing out the full function name.

Not every class make sense with operators like “+” or “-”. I have no idea, for example, what it would even mean to add two Books together or to subtract one Book from another.

There are, however, a few operators that would make sense for Book and for almost all ADTs.

6.2 Assignment

One operator that makes sense for almost all classes is the assigment operator.

Chief among these is the assignment operator. When we write book1 = book2, that’s shorthand for book1.operator=(book2).

Assignment is used so pervasively that a class without assignment would be severely limited (although sometimes designers may want that limitation). Consequently,

If a class does not provide an explicit assignment operator, the compiler will attempt to generate one. The compiler-generated version will simply assign each data member in turn.

6.3 I/O

Another, very common set of operators that programmers often write for their own code are the I/O operators << and >>, particularly the output operator <<.

Indeed, I would argue that you should always provide an output operator for every class you write, even if you don’t expect to use it in your final application.

My reason for this is quite practical. Sooner or later, you’re going to discover that your program isn’t working right. So how are you going to debug it? The most common thing to do is to add debugging output at all the spots where you think things might be going wrong. So you come to some statement:

  doSomethingTo(book1);

and you realize that it might be really useful to know just what the value of that book was before and after the call:

  cerr << "Before doSomethingTo: " << book1 << endl;
  doSomethingTo(book1);
  cerr << "After doSomethingTo: " << book1 << endl;

Now, if you have already written that operator<< function for your Book class, you can proceed immediately. If you haven’t written it already, do you really want to be writing and debugging that new function now, when you are already dealing with a different bug?

We can add output to some of our existing classes:

class Address {
public:

  Address (std::string theStreet = std::string("unknown"),
           std::string theCity = std::string(),
           std::string theState = std::string(),
           std::string theZip = std::string());

  std::string getStreet() const;
  void setStreet (std::string theStreet);

  std::string getCity() const;
  void setCity (std::string theCity);

  std::string getState() const;
  void setState (std::string theState);

  std::string getZip() const;
  void setZip (std::string theZip);

private:
  ⋮
};


std::ostream& operator<< (std::ostream& out, const Address& addr);

The output operator must be declared outside of the class. That’s because, function members of a class are always called with an object of that class type on the left. For example

Address addr;
addr.setState("VA");

For the operator shorthand, that translates to the object being to the left of the operator. E.g., “address1 = address2” is equivalent to “address1.operator=(address2)”.

But look at how we use an output operator:

cout << addr;

The thing on the left is not the ADT we are trying to write – it’s a C++ std::ostream. So operator<< could only be a member function of class std::ostream. And that’s no good for our purposes. So if we want to support output of Address or Author or any of our other classes, we need to do it as an ordinary, non-member function.

Another unusual point: notice the return value on the operator<< declaration. Each implementation of operator<< is supposed to return the output stream to which we are writing. It’s the fact that << is an expression that returns the stream we are writing to that let’s us write “chains” of output expressions like:

cout << book1 << " is better than " << book2 << endl;

which is treated by the compiler as if we had written:

(((cout << book1) << " is better than ") << book2) << endl;

Look at the second <<.

• What is it being given as its left-side parameter? It’s being given (cout << book1), the value returned by the first << operator.
• What do we expect a << to do with its left-side parameter? We expect it to write to it.

So, the left-hand parameter needs to be the output stream that we are writing all of this output to.

By convention, then, every implementation of operator<< returns the stream that it has just written into, so that a chain of << calls will, each in turn, pass the stream on to the next one in line.

6.4 Comparisons

After assignments and I/O, the most commonly programmed operators would be the relational operators, especially == and <. The compiler never generates these implicitly, so if we want them, we have to supply them.

class Address
{
   ⋮
  bool operator== (const Address&) const;
   ⋮
};

The trickiest thing about providing these operators is making sure we understand just what they should mean for each individual ADT. For example, if I were to write

if (address1 == address2)

what would I expect to be true of two Addresses that passed this test? Probably that the two addresses would have the same street, city, state, and zip - in other words, that all the data fields should themselves be equal. In that case, this would be a reasonable implementation:

bool Address::operator== (const Address& right) const
{
  return (street == right.street)
      && (city   == right.city)
      && (state  == right.state)
      && (zip    == right.zip);
}

We could do something similar for Author:

bool Author::operator== (const Author& right) const
{
  return (name       == right.name)
      && (address    == right.address);
 }

which, interestingly, makes use of the Address::operator== that we have just defined.

In C++, we traditionally provide operator< whenever possible, and many code libraries assume that this operator is available.

Again, just what this should mean depends upon the uses we intend to make of our ADT, but there are a few hard and fast rules:

We should always design operator< so that

• If x < y is true, then y < x must be false and x == y must be false.

• If x == y is true, then x < y must be false and y < x must be false.

• If x == y is false, then either x < y must be true or y < x must be true, but both of those should not be true.

7 Other Interface Details

7.1 Const Correctness

In C++, we use the keyword const to declare constants. E.g.,

const double PI = 3.14159;

But it also has two other important uses:

• indicating what formal parameters a function will look at, but promises not to change

• indicating which member functions don’t change the object they are applied to

These last two uses are important for a number of reasons

• This information often helps make it easier for programmers to understand the expected behavior of a function.

• The compiler may be able to use this information to generate more efficient code.

• This information allows the compiler to detect many potential programming mistakes.

class Author
{
public:
  Author();

  Author (std::string theName, const Address& theAddress);

  std::string getName() const;
  void setName (std::string theName);

  const Address& getAddress() const;
  void setAddress (const Address& addr);

  int numberOfBooks() const;
  std::string& getBook(int i);
  const std::string& getBook(int i) const;

  void addBook (Book& b);
  void removeBook (Book& b);

  bool operator== (const Author& right) const;
  bool operator< (const Author& right) const;


private:
  ⋮
};

• For example, the setName function does not alter the string that it receives as a parameter, so that parameter is passed by copy, as are all the others highlighted like this.

• Similarly, the setAddress function does not alter the Address that it receives as a parameter, so that parameter is passed by const reference.

• The getName and getID functions do not alter the Author they are applied to, so they are marked as const member functions. It’s a pretty sure bet that most functions named “get…” are supposed to fetch data and not change the object that they are applied to.

Similarly, when we use == or < to compare one author to another, we would expect that such a comparison would not affect the value of the author to the left of the operator, so we mark these functions as const also.

7.1.1 Const Member Function Pairs

It’s worth highlighting one peculiarity that const correctness introduces to ADT interfaces. Look at these member functions:

class Author
{
public:
    ⋮
  std::string& getBook(int i);
  const std::string& getBook(int i) const;
    ⋮
};

The first of these will be applied to Authors that are not const. The second will be applied to Author objects that are const. For example,

void transferFirstBook (const Author& a, Author& b)
{
    string title = a.getBook[0];   // uses 2nd, const versions
    b.getBook(0) = title;          // uses 1st, non-const version
    a.getBook(0) = "out of print"; // Compilation error!
}

The first version returns a reference (address) of the author’s book and so can actually be used to change the book inside the Author object.

The second version returns a const reference, which cannot be be changed. And that is entirely consistent with the fact that the book a is itself marked as const, which is a promise by transferFirstBook that it will not do anything that could change the value of a.

This use of paired functions differing only in the const-labels on the function, its parameters, and its return type, is a very common pattern in C++.

7.2 Inline Functions

Many of the member functions we have given as examples are simple enough that we might consider an alternate approach, declaring them as inline functions.

When we define a function, it is usually compiled into a self-contained unit of code. For example, the function

int foo(int a, int b)
{
  return a+b-1;
}

would compile into a block of code equivalent to

stack[1] = stack[3] + stack[2] - 1; 
jump to address in stack[0]

where the “stack” is the runtime stack a.k.a. the activation stack
used to track function calls at the system level, stack[0] is the top value on the stack, stack[1] the value just under that one, and so on. A function call like

  x = foo(y,z+1);

would be compiled into a code sequence along the lines of

push y onto the runtime stack; 
evaluate z+1; 
push the result onto the runtime stack
push (space for the return value) onto the runtime stack 
save all CPU registers
push address RET onto the runtime stack 
jump to start of foo's body 
RET: x = stack[1] 
pop runtime stack 4 times 
restore all CPU registers

As you can see, there’s a fair amount of overhead involved in passing parameters and return address information to a function when making a call. The amount of time spent on this overhead is not really all that large. If the function body contains several statements in any kind of loop, then the overhead is probably a negligable fraction of the total time spent on the call. But if the function body is only a line or two and does not involve a significant amount of computation, then the time spent on that overhead can be, by comparison, quite large.

Many ADTs have member functions that are only one or two lines long, and often trivial lines at that. In our Book class, for example, we might feel that all of our get... and set... functions meet that description.

For these functions, the overhead associated with each call may exceed the time required to do the function body itself. Furthermore, because these functions are often the primary means of accessing the ADT’s contents, sometimes these functions get called thousands of times or more inside the application’s loops, causing the total amount of time spent on the overhead of making the function call to become significant.

For these kinds of trivial functions, C++ offers the option of declaring them as inline.

An inline function can be written one of two ways, both of which are illustrated here:

class Address {
public:

  Address (std::string theStreet = std::string("unknown"),
           std::string theCity = std::string(),
           std::string theState = std::string(),
           std::string theZip = std::string());

  std::string getStreet() const {return street;}
  void setStreet (std::string theStreet) {street = theStreet;}

  std::string getCity() const {return city;}
  void setCity (std::string theCity) {city = theCity;}

  std::string getState() const {return state;}
  void setState (std::string theState) {state = theState;}

  std::string getZip() const {return zipcode;}
  void setZip (std::string theZip) {zipcode = theZip;}

  bool operator== (const Address& right) const;
  bool operator< (const Address& right) const;

private:
  std::string street;
  std::string city;
  std::string state;
  std::string zipcode;
};

inline Address::Address (std::string theStreet, std::string theCity,
        std::string theState, std::string theZip)
{
  street = theStreet;
  city = theCity;
  state = theState;
  zipcode = theZip;
}


std::ostream& operator<< (std::ostream& out, const Address& addr);

1. It can be written inside the class declaration.
2. We can place the reserved word inline in front of the function definition written in its usual place outside the class declaration.

Either way, we then remove the function body from the .cpp file.

When we make a call to an inline function, the compiler simply replaces the call by a compiled copy of the function body (with some appropriate renaming of variables to avoid conflicts).

So, if we have

inline int foo(int a, int b)
{
  return a+b-1;
}

and we later make a call

  x = foo(y,z+1);

This would be compiled into a code sequence along the lines of

evaluate z+1, storing result in tempB 
evaluate y + tempB - 1, storing result in x

Most of the overhead of making a function call has been eliminated.

Inline functions can reduce the run time of a program by removing unnecessary function calls, but, used unwisely, may also cause the size of the program to explode. Consequently, they should be used only by frequently-called functions with bodies that take only 1 or 2 lines of code. For larger functions, the times savings would be negligible (as a fraction of the total time) while the memory penalty is more severe, and for infrequently used functions, who cares?

Inlining is only a recommendation from the programmer to the compiler. The compiler may ignore an inline declaration and continue treating it as a conventional function if it prefers. In particular, inlining of functions with recursive calls is impossible, as is inlining of most virtual function calls (don’t worry if you don’t know what those are). Many compilers will refuse to inline any function whose body contains a loop. Others may have their own peculiar limitations.