• Are a C++ enhancement designed to speed up programs

The primary distinction between normal functions and inline functions

• Is not in how you code them
  • But in how the C++ compiler incorporates them into a program

To understand the distinction between inline functions and normal functions

• You need to peer more deeply into a program’s innards than we have so far
  • Let’s do that now

The final product of the compilation process

• Is an executable program, which consists of a set of machine language instructions
  • When you start a program, the operating system loads these instructions into the computer’s memory so that each instruction has a particular memory address
    • The computer then goes through these instructions step-by-step

Sometimes, as when you have a loop or a branching statement

• Program execution skips over instructions, jumping backward or forward to a particular address

Normal function calls

• Also involve having a program jump to another address (the function’s address)
  • And then jump back when the function terminates

Let’s look at a typical implementation of that process in a little more detail

• When a program reaches the function call instruction
  • The program stores the memory address of the instruction immediately following the function call
    • Copies function arguments to the stack (a block of memory reserved for that purpose)
      • Jumps to the memory location that marks the beginning of the function
        • Executes the function code (perhaps placing a return value in a register)
          • And then jumps back to the instruction whose address it saved

Jumping back and forth and keeping track of where to jump

• Means that there is an overhead in elapsed time to using functions

C++ inline functions

• Provide an alternative

In an inline function

• The compiled code is “in line” with the other code in the program
  • That is, the compiler replaces the function call with the corresponding function code

With inline code

• The program doesn’t have to jump to another location to execute the code and then jump back
  • Inline functions thus run a little faster than regular functions
    • But they come with a memory penalty

If a program calls an inline function at 10 separate locations

• Then the program winds up with 10 copies of the function inserted into the code
  • See (Image-1)

(Image-1)  Inline functions versus regular functions

You should be selective about using inline functions

• If the time needed to execute the function code is long compared to the time needed to handle the function call mechanism
• Then the time saved is a relatively small portion of the entire process
• If the code execution time is short
• Then an inline call can save a large portion of the time used by the non-inline call
• On the other hand, you are now saving a large portion of a relatively quick process, so the absolute time savings may not be that great unless the function is called frequently

To use this feature, you must take at least one of two actions:

• Preface the function declaration with the keyword inline
• Preface the function definition with the keyword inline

A common practice is

• To omit the prototype
  • And to place the entire definition (meaning the function header and all the function code) where the prototype would normally go

The compiler does not have to honor your request to make a function inline

• It might decide the function is too large
  • Or notice that it calls itself (recursion is not allowed or indeed possible for inline functions)
    • Or the feature might not be turned on or implemented for your particular compiler

(A-1) illustrates the inline technique with an inline square() function that squares its argument

• Note that placed the entire definition is on one line
  • That’s not required, but if the definition doesn’t fit on one line, the function is probably a poor candidate for an inline function

Example of (A-1)

// inline.cpp -- using an inline function
#include <iostream>
 
// an inline function definition
inline double square(double x) { return x * x; }
 
int main()
{
	using namespace std;
	double a, b;
	double c = 13.0;
 
	a = square(5.0);
	b = square(4.5 + 7.5); // can pass expressions
	cout << "a = " << a << ", b = " << b << "\n";
	cout << "c = " << c;
	cout << ", c squared = " << square(c++) << "\n";
	cout << "Now c = " << c << "\n";
	return 0;
}

Here’s the output of the program in (A-1):

This output illustrates that inline functions pass arguments by value just like regular functions do

• If the argument is an expression, such as 4.5 + 7.5, the function passes the value of the expression—12 in this case
  • This makes C++’s inline facility far superior to C’s macro definitions
    • See the “Inline Versus Macros”

Even though the program doesn’t provide a separate prototype, C++’s prototyping features are still in play

• That’s because the entire definition, which comes before the function’s first use, serves as a prototype
  • This means you can use square() with an int argument or a long argument
    • And the program automatically type casts the value to type double before passing it to the function

Inline Versus Macros

The inline facility is an addition to C++

• C uses the preprocessor #define statement to provide macros
  • Which are crude implementations of inline code
    • For example, here’s a macro for squaring a number (A-2):

Example of (A-2)

#define SQUARE(X) X*X

(A-2) this works not by passing arguments but through text substitution

• With the X acting as a symbolic label for the “argument” (A-3):

Example of (A-3)

a = SQUARE(5.0); // is replaced by a = 5.0*5.0;
b = SQUARE(4.5 + 7.5); // is replaced by b = 4.5 + 7.5 * 4.5 + 7.5;
d = SQUARE(c++); // is replaced by d = c++*c++;

(A-3) only the first example here works properly

• You can improve matters with a liberal application of parentheses (A-4):

Example of (A-4)

#define SQUARE(X) ((X)*(X))

Still, the problem remains that macros don’t pass by value

• Even with this new definition, SQUARE(c++) increments c twice
  • But the inline square() function in (A-1) evaluates c, passes that value to be squared, and then increments c once

The intent here is not to show you how to write C macros

• Rather, it is to suggest that if you have been using C macros to perform function-like services
  • You should consider converting them to C++ inline functions

• Is a series of characters stored in consecutive bytes of memory

C++ has two ways of dealing with strings

• The first, taken from C and often called a C-style string, is the first one this page examines
• Later, we will discuss an alternative method based on a string class library

The idea of a series of characters stored in consecutive bytes

• Implies that you can store a string in an array of char
  • With each character kept in its own array element

Strings provide a convenient way to store text information

• Such as messages to the user (“Please tell me your secret Swiss bank account number”)
  •  Or responses from the user (“You must be joking”)

C-style strings have a special feature:

• The last character of every string is the null character
  • This character, written \0, is the character with ASCII code 0, and it serves to mark the string’s end
    • For example, consider the following two declarations (A-1):

Example of (A-1)

char dog [5] = { 'h', 'u', 's', 'k', 'y'}; // not a string!
char cat[5] = {'f', 'a', 't', 's', '\0'}; // a string!

(A-1) both of these arrays are arrays of char

• But only the second is a string

The null character plays a fundamental role in C-style strings

• For example, C++ has many functions that handle strings, including those used by cout
• They all work by processing a string character-by-character until they reach the null character
• If you ask cout to display a nice string like cat in the preceding example
• It displays the first four characters, detects the null character, and stops
• But if you are ungracious enough to tell cout to display the dog array from the preceding example, which is not a string
• cout prints the five letters in the array and then keeps marching through memory byte-by-byte, interpreting each byte as a character to print, until it reached a null character
• Because null characters, which really are bytes set to zero
• Tend to be common in memory, the damage is usually contained quickly; nonetheless, you should not treat nonstring character arrays as strings

The cat array example makes initializing an array to a string look tedious

• All those single quotes and then having to remember the null character
  • Don’t worry. There is a better way to initialize a character array to a string
    • Just use a quoted string, called a string constant or string literal, as in the following (A-2):

Example of (A-2)

char bird[10] = "Mr. Cheeps"; // the \0 is understood
char fish[] = "Bubbles"; // let the compiler count

Quoted strings always include the terminating null character implicitly

• So you don’t have to spell it out
  • See (Image-1)

(Image-1) Initializing an array to a string
 

Also, the various C++ input facilities for reading a string from keyboard input into a char array

• Automatically add the terminating null character for you

Of course, you should make sure the array

• Is large enough to hold all the characters of the string
  • Including the null character

Initializing a character array with a string constant

• Is one case where it may be safer
  • To let the compiler count the number of elements for you

 


There is no harm, other than wasted space, in making an array larger than the string

• That’s because functions that work with strings are guided by the location of the null character
  • Not by the size of the array

C++ imposes

• No limits on the length of a string

Remember

• When determining the minimum array size necessary to hold a string
  • Remember to include the terminating null character in your count

Note that a string constant (with double quotes)

• Is not interchangeable with a character constant (with single quotes)

A character constant

• Such as ‘S’, is a shorthand notation for the code for a character
  • On an ASCII system, ‘S’ is just another way of writing 83
    • Thus, the following statement assigns the value 83 to shirt_size (A-3):

Example of (A-3)

char shirt_size = 'S'; // this is fine

But “S” represents the string consisting of two characters

• The S and the \0 characters
  • Even worse, “S” actually represents the memory address at which the string is stored
    • So the following statement attempts to assign a memory address to shirt_size (A-4):

Example of (A-4)

char shirt_size = "S"; // illegal type mismatch

Because an address is a separate type in C++

• A C++ compiler won’t allow this sort of nonsense
  • (We’ll return to this point later, after we’ve discussed pointers.)