[C++] Fucntions

Statements

A break statements terminate the nearest wile, do while, for or switch statement. A break affect only the nearest enclosing loop or switch.

As any block, variables declared inside a try block are inaccessible outsite the block - in particular, they are not accessible to the catch clauses.

Exception.

A try block maigh call a function that contains a try which calls another funciton with its own try and so on. The search for a hander reverses the call chain. If no appropriate catch is found, execution is transfered to a library function name terminate. The terminate will garantee to stop further execution of th problem.

If there are no try blocks, they can be no handlers. If a program no try blocks and an exception occurs, then terminate is called and program is exited.

Programs that properly "clean up" during execution handling are saied to be "exception safe".

Functions

Parameters and Arguments

Arguments are the initilizers for a function's parameters.

Local Objects

In C++, names have scopes, and objects have lifetimes

• The scope of a name is the part of the program's text in which that name is visible.
• The lifetime of an object is the time during the program's execution that the object exists.

Parameters and variables defined inside a function body are refered to as local variables. They are "local" to that function and hide declaration of the same name made on outer scope.

Obejcts defined outside any functions exist through the program's execution. Such object are created then the program starts and not destroyed until the program ends

The lifetime of varibles depends on how it is defined.

Automatic object. Objects that exist only when a block is execution are known as automatic objects.

local static object. Each local static object is initilized before the first time execution pass through the object's definition. Local static objects are not destroyed when a funciton ends; they are destroyed when the program terminated.

size_t count_calls(){
    static size_t ctr = ;    // value will persist across calss
    ctr++;
    return ctr;
}
int main(){
    for (size_t i = ; i != ; i++){
        cout << count_calls() << endl;
    }
}

This program will print the number from 1 through 10 inclusive.

Function declartions are also known as the function prototype.

Recall that variables are declared in haeder files and defined in source file. Function should be declared in header files and defined in source file.

The header that declares a funciton should be included in that source file tha defines that function.

Argument Passing

Parameter initialization works the same way as variable initialization.

If the parameter is a reference then the parameter is bound to its argument. Otherwise, the argument's value is copied.

When aprameter is a reference, we say that its correspondency argument is "passed by reference", or that function is "called by referenced". As with any other reference, a reference paramter is an alisa for the object to which it is bound.

When the argument value is copied. the parametr and argument are independent object. We say such arguments are "passed by value", or the function is "called by value".

When we initiliaze a non-reference type variable or parameter, the value of the initializer is copied.

Pointers behave like any other non-reference type. When we copy a pointer, the value of the pointer is copied. After the copy, the two pointers are distinct, but pointing to the same object.

void reset(int *ip){
    *ip = ;    // change the value of the object to which ip points
    ip = ;    // change the local pointer; the argument is unchanged.
}

Usage:

int i = ;
reset(&i);    // change i, but not the address of i

Programmers accustomed to programming in C often use pointer paramters to access objects outside a function. In C++, programmers generally use reference parameters instead.

Recall that operations on a reference are actully operations on the object to which the reference refers

void reset(int &i){    // i is just another name for the object passed to reset
    i = ;    　　　　　 // change the value of the objet to which i refers
}

When we call this version of reset, pass an object directly, no need to pass its address.

int j = ;
reset(j);        // passed by reference, the value on j is changed

Reference parameter that are not changed inside a function should be references to const.

Never return a reference or pointer to a local object.

When a function completes, its storage is free. After a function terminates, references to local object refer to memory that is no long valid.

// disaster: this function returns a reference to a local object
const string &mapip(){
    string ret;
    if(!ret.empty()){
        return ret;    // WRONG: return a reference to a local object
    }else{
        return "Empty";    // WRONG: "Empty" is a local object
    }
}

References returns are lvalues

Calls to function that return references are lvalu. Other return types is rvalue.

char &get_val(string &str, string::size_type ix){
    return str[it];
}
int main(){
    string s("a value");
    get_value(s, ) = 'A'; // change s[0] to A
    return ;
}

Overload Functions

Functions that have the same name but different parameter lists and that appear in the same scope are overload.

Default Arguments

sz wd = ;
char def = ' ';
char ht();

string screen(sz = ht(), sz = wd, char = def);

void f2(){
    sz wd = ;    // hide the definition of wd, but not change the default
    def = '*';    // change the default
    window = screen();    // call screen(ht(), 80, '*')
}

Reference:

C++ Primer, Fifth Edition, chapter 6 Functions