CIS 3142 Advice — Chapter 1

[1] 'Package' meaningful operations as carefully named functions; §12.1.

'Augenstein's rule' — if you can give the task a name, or describe it in a sentence, make it a function

[2] A function should perform a single logical operation; §12.1.

the simpler the better

[3] Keep functions short; §12.1.

Stroustrup: "keep a function to a size so that you can look at it in total on a screen'
bugs are kept to a minimum when the entire algorithm can be viewed at once
related to [12.2]

[4] Don't return pointers or references to local variables; §12.1.4.

Local variables go out of scope (i.e., their lifetimes end) when the function returns, returning a reference or pointer to such an object results in a dangling pointer to an location on the call stack that will be overwritten at a next function call

[5] If a function may have to be evaluated at compile time, declare it constexpr; §12.1.6.
[6] If a function cannot return, mark it [[noreturn]]; §12.1.7.
[7] Use pass-by-value for small objects; §12.2.1.

They're small, so there's little overhead in copying and passing
This is usually limited to predefined types, since one might not know if a class object is indeed small, or even if it is, if it might eventually grow larger.

[8] Use pass-by-const-reference to pass large values that you don't need to modify; §12.2.1.

by-reference avoids the copy; const eliminates the possibility of inadvertent modification with the function

[9] Return a result as a return value rather than modifying an object through an argument; §12.2.1.

due to the transparent nature of passing references, at the point of the call, one cannot tell that the argument is passed by reference
returning a value, on the other hand is quite explicit

[10] Use rvalue references to implement move and forwarding; §12.2.1.
[11] Pass a pointer if 'no object' is a valid alternative (and represent 'no object' by nullptr); §12.2.1.

pointers can be assigned nullptr; there is no such mechanism for references (or most pre-defined types and class objects)
if the logic requires a 'no object' (e.g., a search function returning 'no object' if the object is not found), one might consider using a pointer

[12] Use pass-by-non-const-reference only if you have to; §12.2.1.

related to [12.9] — one can't tell at the point of call that call-by-reference is being used; and the lack of the const opens up the possibility of accidental modification

[13] Use const extensively and consistently; §12.2.1.

const represents immutability; if something need not be modified, it should not be allowed to

[14] Assume that a char* or a const char* argument points to a C-style string; §12.2.2.

it's more a matter of that's what those types are used for, than any strict language feature

[15] Avoid passing arrays as pointers; §12.2.2.
[16] Pass a homogeneous list of unknown length as an initializer_list (or as some other container); §12.2.3.
[17] Avoid unspecified numbers of arguments (...); §12.2.4.
[18] Use overloading when functions perform conceptually the same task on different types; §12.3.

if the name of the function describes the task, should use the same name if the task is similar, but the signature is different

[19] When overloading on integers, provide functions to eliminate common ambiguities; §12.3.5.

the numerous integral types and their implicit conversions can often lead to overload ambiguities

[20] Specify preconditions and postconditions for your functions; §12.4.
[21] Prefer function objects (including lambdas) and virtual functions to pointers to functions; §12.5.
[22] Avoid macros; §12.6.

they are outside the rules of the language (they are mere textual replacement)

as a corollary, they often have unintended effect

#define TWICE(x) 2*x
…
int a = 2;
int b = TWICE(a+1);		// expands to 2*a+1 -> 5, not 6 
cout << b;

[23] If you must use macros, use ugly names with lots of capital letters; §12.6.

so they stand out

CISC 3142
Programming Paradigms in C++
Part II: Basic Facilities
Chapter 12 - Functions

Overview

Topics

Function Declarations

Function Definition

Returning From (Exiting) a function

Argument Passing

Array Arguments

Overloaded Functions

Macros

Advice

Code Used in this Lecture

CISC 3142 Programming Paradigms in C++ Part II: Basic Facilities Chapter 12 - Functions

Overview

Topics

Function Declarations

Function Definition

Returning From (Exiting) a function

Argument Passing

Array Arguments

Overloaded Functions

Macros

Advice

Code Used in this Lecture

CISC 3142
Programming Paradigms in C++
Part II: Basic Facilities
Chapter 12 - Functions