TITLE: Inlines calling inlines - hidden size costs

[ This material comes from "C++ Strategies and Tactics" by
  Robert B. Murry, p. 243 ]

Even if you inline only one-line functions, you can still make some
pretty big functions. A one-liner may call two or three functions that
are also inline; each of those functions may in turn call two or three
inline functions, and so on.

Consider these apparently reasonable inline functions:

	class Telephone_number {
	  public:
		// details omitted
		String area_code() { /* ... */ }
		String exchange() { /* ... */ }
		String number() { /* ... */ }
		String formatted() { return "(" + area_code()
			+ ")" + exchange() + "-" + number(); }
	};

How big do you think Telephone_number::formatted is? In addition to calls
to area_code, exchange, and number, there are also five calls to 
operator+(String, String). Any or all of these calls may be inline. But
that is not all - four Strings to hold intermediate results are also
created and destroyed. On my system, where the only inline functions are
the three members of Telephone_number plus string constructors and 
assignment, each call to formatted generates 552 bytes of code! This was 
large enough that the compiler simply refused to inline it [...] Consider
what would have happened if String::operator+ was inline too!. This is one
reason why C++ programs sometimes turn out to be larger than expected.