[C++]C++小笔记 ----- 函数

分手后的思念是犯贱 2022-09-20 08:39 141阅读 0赞

## 1. 函数创建 ##

In C++, 创建函数分为三个步骤：

1.  函数声明 / function prototyping, function prototyping is not optional in C++. prototyping happens during compile time and is termed as "static type checking". It helps to check errors that are hard to find during run-time; 
2.  函数定义；
3.  调用函数；

例子：

#include <iostream>
    using namespace std;
    
    //1. function prototype.
    void simple();
    
    int main() {
    	cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!
    	//3. call functions.
    	simple();
    	return 0;
    }
    
    /*
     * 2. function definition.
     */
    void simple() {
    }

1. 函数声明

为什么要有函数声明呢？

1.  函数声明向编译器描述了函数接口， 即， return type and number & type of parameters. 当一个有返回值的函数结束运算的时候，调用这个函数的函数，也许是main()需要从CPU寄存器/内存中读取这个返回值。因为函数声明指定了返回值的类型，所以compilers知道how many bytes to read and how to intercept them.
2.  编译器可以确保程序员使用了正确的参数数目， 类型， 以及 return type.

函数声明带参数时，参数类型可以不带参数名。

int cal(int); 
    int cal(int value);

如果声明中带参数名，函数定义时的参数名可以与声明时的参数名不同。

Leaving the parentheses empty is the same as using the keyword "void" in the parentheses.

int cal(); == int cal(void);

# 2. 函数参数 #

C++ normally passes arguments *by value.*  That means

int cal(double side);

The value of variable side  is passed to function cal(). A copy of side's value is stored in cal() and cal() works with the copy of "side"  rather than with its original value.

![Center][]

Parameters and variables declared inside a function are private to the function. They are called*Local Variables.*When a function is called, the computer allocates memory for these local variables. When a function terminates, the computer frees the memory that are used by those variables automatically.

### 1. 函数参数与数组 ###

当数组被用来当作参数传递给函数时，数组是作为指针传递到函数中去的, 数组将自己的地址传给了函数。

所以， 下面的使用方法是可以的。

#include <iostream>
    using namespace std;
    
    //function prototype.
    int simple(int arr[], int size);
    int complex(int * arr, int size);
    
    int main() {
    	cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!
    	const int size = 8;
    	int cookies[size] = { 1, 2, 3, 4, 5, 6, 7, 8 };
            const int * px = &size;
    	cout<<"The size of cookies "<<sizeof(cookies)<<endl;
    	cout<<cookies<<" = The address of cookies"<<endl;
            cout<<"The size of px "<<sizeof(px)<<endl;
    	//call functions.
    	double temp = simple(cookies, size);
    	cout << "total is " << temp << endl;
    
    	temp = complex(cookies, 3);
    	cout<<"The first 3 eaters ate ";
    	cout<<temp<<endl;
    
    
    	temp = complex(cookies + 5, 3);
    	cout<<"The last 3 eaters ate ";
    	cout<<temp<<endl;
    
    	return 0;
    }
    
    int complex(int * arr, int size) {
    	double total;
    	total = 0;
    
    	cout<<"The size of complex cookies "<<sizeof(arr)<<endl;
    	cout<<arr<<" = The address of complex cookies"<<endl;
    
    	for (int i = 0; i < size; i++) {
    		total += arr[i];
    	}
    	return total;
    }
    
    /*
     * function definition.
     */
    int simple(int arr[], int size) {
    	double total;
    	total = 0;
    	cout<<"The size of simple cookies "<<sizeof(arr)<<endl;
    	cout<<arr<<" = The address of simple cookies"<<endl;
    
    	for (int i = 0; i < size; i++) {
    		total += arr[i];
    	}
    	return total;
    }

结果。

The size of cookies 32

The size of px 8
    0x7fff57c72840 = The address of cookies
    The size of simple cookies 8
    0x7fff57c72840 = The address of simple cookies
    total is 36
    The size of complex cookies 8
    0x7fff57c72840 = The address of complex cookies
    The first 3 eaters ate 6
    The size of complex cookies 8
    0x7fff57c72854 = The address of complex cookies
    The last 3 eaters ate 21

从结果来看，cookies是数组和指针时， 它的地址是一样的。但是他们的sizeof()不同，sizeof(Type Array) reutrns the size of the whole array, while the sizeof(pointer-to-int) only returns the size of the pointer. 所以，在方法中我们不用sizeof()传来的array来计算数组的size.

因为数组是作为指针传递给函数的， 所以函数是直接在original array上操作，而不是在copy上。如果想让函数无法修改数组的值，可以使用keyword

const.

void show_array(const double ar[], int n);

This indicates that ponter 'ar' points to const double values. ***However, This does not means that the original array needs to be constant, it just means that you cannot alter the content of array 'ar' in function 'show\_array()'.***

int show_array(const double ar[],int size);
    
    int main() {
    	double ar[2] = {1,2};
    	show_array(ar, 2);
    	return 0;
    }
    
    int show_array(const double ar[], int limit) {
    	for( int i = 0; i < limit; i++) {
    		cout<<ar[i] <<" ";
    	}
    	cout<<endl;
    }

'ar' is an array whose contents are const doubles.

const double ar[] == const double *ar;

'ar' is a pointer that ponits to const double values.

### 2. 函数参数---数组的长度 ###

我们之前通过一个证书来指定数组的长度。其实我们也可以通过ranges的方式来指定数组的长度。

int * pt = new int[2];

pt指向长度为2的数组。pt指向第一个元素，pt+1指向第二个。pt+2指向数组结尾后的元素。Thus,

int * pe = pt+2;

double array_ranges(const double *begin, const double *end);
    
    int main() {
    	double ar[2] = {1,2};
    
    	double temp = array_ranges(ar, ar+2);
    	cout<<" total is "<< temp<<endl;
            return 0;
    }
    
    double array_ranges(const double *begin, const double * end) {
    	double total = 0;
    	const double * member;
    	for(member = begin; member!=end; member++) {
    		total += *member;
    	}
    	return total;
    }

数组的首个元素的地址被传递到函数中。

### ***3. 函数和二维数组*** ###

int data[3][4] = {
        {1,2,3,4}, {9,8,7,6}, {2,4,6,8}};
    int total = sum(data, 3);

data is a pointer-points-to-array-of-4-int. so the appropriate way to define it is.

int total(int (*arr)[4], int size);

(\*arr) means arr is an pointer. The int means arr points to an int arry with size of 4.

An alternative format that means exactly the same thing but easier to read is

int sum(int arr[][4], int size);

Either way, arr is a pointer.

int sum(int arr[][4], int size)
    {
    int total = 0;
    for (int r = 0; r < size; r++)
    for (int c = 0; c < 4; c++)
    total += arr[r][c];
    return total;
    }

### 4. 函数与struct ###

struct与其他基本类型一样，在C++中是值传递。struct也可以用指针传递。基本上有两个方式。

1. struct变量是指针,

void test(structX *);   //prototype.
    
    structX *m = new structX(...);
    test(m);

2.struct变量是object。

void test(structX *);
    
    structX m = {....};
    test(&m);

## 函数与函数指针 ##

函数指针分为三步：

1.  obtaining the address of a function;
    
    1.  The name of a function is a pointer to that function's address in memory of the machine code.
    2.  The pointer to a function should also acts like a pointer to the address of that function.
2.  Declare the pointer to a function;
    
    1.  a function pointer need to specify the return value and parameter of the function.

int function1(int);   //function prototype.
    int (*fp)(int);  //declare a function pointer.
    fp = function1;

() have higher rank than \*, so

*fp(int)  //A function pt with parameter type int and return a pointer.
    (*fp)(int) //A function pointer pt with parameter type int.

1.  Use Function pointers

int x = (*fp)(10);

C++ also allow

int y = fp(10);

Because of the second point in " *obtaining the address of a function;* "

## Array of function pointers. ##

以下参个函数

const double * (*f1)(const double ar[], int x);
    const double * (*f2)(const double [], int);
    const double* (*f3)(const double *, int);

其实拥有相同的参数列表。因为

1. const double ar\[\] == const double \* ar;

2. const double \[\] == const double ar\[\];          //function prototype can omit the identifiers.

So,

const double * (*pa)(const double *, int); //is a function pointer.

也可以在声明的时候同时赋值。

const double * (*pa)(const double *, int) = f1;

auto pa = f1;

### Array of function pointers. ###

Array of X pointers

const double * (*pa[3])(const double * , int ) = {f1, f2, f3};

\[\] has higher rank than \*, so \*pa\[3\] is an array of three pointers. each of which  is a pointer to a function that takes a const double \* and int as arguments and return a const double \*.

We can also do

auto pb = pa;

because the name of an array is the pointer to the first element of the array. so both of pa and pb

are pointers to a pointer to a function. both pa\[0\] and pb\[0\] are pointers to function. so

const double * px = pa[0](av, 3); 
    OR
    cosnt double * py= (*pa[0])(av, 3);

## Pointer to an array of function pointers. ##

*pd[3];           // array of three pointers.
    (*pd)[3];        // pa is a pointer which points to array of three elements.

To combine above two togather,

const double *  (* /*pointer-to-*/ (*pd[3])/* array of three pointers*/)(const double *, int) = &pa;

Thus, pd points to an array, then \*pd is the array of function pointers. (\*pd)\[i\] is an array element, which is a pointer to a function.

To call a function,

(*pd)[i](av, 3);    //function pointer
    OR
    *(*pd)[i](av, 3);   //actual function address