C++ 教程 - 03 函数篇

函数定义

• 函数是将一部分代码进行封装，便于重用、维护，使得代码更加的整洁。

• 定义函数格式
  类型 函数名（形参类型 形参名称，…）{ 函数体； return 类型值；}

• 函数调用使用 函数名(实参)，传入实参个数和类型要与形参对应；类型不匹配时，会隐式转换，若无法转换，则报错；

• 函数定义代码

// 求和
int sum(int a, int b){
	int c = a + b; //
	return c;
}

函数案例

• 求$2^{10}$ 的值；->1024

// pow 函数可以求幂运算
int calc(int base, int exponential){
	return pow(base, exponential);
}

 

• 输入一个非负整数n，求n的阶乘；

// 递归
int calcFactorial(int n) {
	if (n == 0 || n == 1) {
		return 1;   // 有明确的返回条件
	}
	return n * calcFactorial(n - 1); // 递归  函数调用自身
}

// 入口函数
int main() {

	cout << calcFactorial(6) << endl;

	return 0;
}

 

• 输入一个非负整数n，求1-> n的斐波那契数列；
  • n为0、1时，f(n) = 1;
  • $f(n)=f(n-1)+f(n-2);n>=2$，即从第三项开始，每一项均为前两项之和。
  • 递归思想，函数调用自身且函数有明确的返回条件；

// 计算斐波那契每一项的值
int calcFibonacci(int n) {
	if (n == 0 || n == 1) {
		return 1;
	}

	return calcFibonacci(n - 1) + calcFibonacci(n - 2);
}


// void 表示无返回值
void outputValue(int n) {
	// cout 输出到控制台  << 流输出运算符
	cout << calcFibonacci(n)<< " ";
}


// 入口函数
int main() {

	cout << "输入一个自然数:" << endl;

	// 控制台输入  >> 流输入运算符
	int n;
	cin >> n;

	// 循环输出n以内的斐波那契数列
	for (int i = 0; i <= n; i++) {
		outputValue(i);
	}

	return 0;
}

 

作用域

• 函数内的变量及形参都是局部变量，只在函数内部可以使用；
• 函数外部的变量为全局变量，全局可以使用，其他源文件也可以引用；
• static 修饰的局部变量为局部静态对象(默认初始化为0)，函数每次压栈执行时，静态对象的值不会重置； 而局部变量在函数每次压栈执行时创建，返回出栈时销毁；
• static 修饰的全局变量为全局静态对象，只能在本源文件中使用；

// 统计一个函数被调用的次数
int callTime(int p) {
	static int times; // 静态对象 默认初始化为0; 而局部变量（自动对象，存在栈中）必须自己初始化;

	times++;
	return times;
}

• 如果函数在调用时，在此之前的代码中尚未定义，则必须先声明该函数，才可以调用；
  • 如 int callTime(int p); 为函数声明，去掉函数体；
  • 形参名也可以省略；
• 在a.cpp源文件中定义一个函数F，可以在b.cpp中调用，调用前只需简单声明即可；c.app中要调用该函数也需要提前声明；
• 为了避免多次调用需多次声明，可以创建一个头文件，并在该头文件中声明一次，其他源文件包含该头文件即可；
  

// a.cpp
#include <string>
using namespace std;

string getName() {
	string name = "jack";
	return name;
}

// lauf.h 头文件
#pragma once  // 仅编译一次
#include <string>
using namespace std;


// 函数声明
string getName();



// b.cpp  包含头文件，并调用函数
#include <iostream>
#include "lauf.h" // 包含自定义的头文件
using namespace std;


// 入口函数
int main() {

	cout << getName() << endl; // 直接调用函数
	return 0;
}

 

函数传参

• 值传递，实参的值拷贝一份，给形参； 实参、形参互不影响；
• 引用传递，将实参的别名传给形参，实参、形参指向同一地址；

bool cmpStr(string str1, string str2){ // 值传递
	return str1.size() > str2.size();
}


bool cmpStr(string& str1, string& str2){ // 引用 别名  传递
	return str1.size() > str2.size();
}

// 尽量使用常量引用 作为形参
bool cmpStr(const string& str1, const string& str2){ // 常量引用  传递
	return str1.size() > str2.size();
}


// 调用时，传入实参  形式相同
string s1 = "jack";
string s2 = "tom";
cmpStr(s1, s2);  // 传值 还是传引用  取决于形参类型

• 数组传递，数组不允许直接拷贝；
  • void operateArr(const int arr[ ], int size){}; 实参传入数组名（首地址）
  • void operateArr(const int* ptr, int size){}; 实参传入数组名;
  • void operateArr(const int(& arr)[10]){}; 实参传入数组名，进行数组的引用；

// 数组拷贝
#include <iostream>
#include "lauf.h" // 包含自定义的头文件
using namespace std;

void printArray(const int arr[], int size) { // 数组无法直接拷贝； 故函数内部无法使用sizeof计算数组的大小，所以必须传入数组的大小；
	for (int i = 0; i < size; i++) {
		cout << arr[i] << endl;
	}

}

// 入口函数
int main() {

	// 定义一个数组， 常量指定长度
	int arr[5] = { 1, 2, 1, 3, 4 };
	printArray(arr, 5);  // 数组无法直接拷贝
	return 0;
}





// 数组引用
#include <iostream>
#include "lauf.h" // 包含自定义的头文件
using namespace std;

void printArray(int(&arr)[5]) { // 必须指定长度
	for (int i : arr) {
		cout << i << endl;
	}

}

// 入口函数
int main() {

	// 定义一个数组， 常量指定长度
	int arr[5] = { 1, 2, 1, 3, 4 };
	printArray(arr);
	return 0;
}




// *********************
// 修改数组的值
#include <iostream>
#include "lauf.h" // 包含自定义的头文件
using namespace std;

void modifyArray(int (&arr)[5]) { // 必须指定长度
	
	// 引用数组  可以使用sizeof 计算大小
	int size = sizeof(arr) / sizeof(arr[0]);
	cout << size << endl;
	for (int i = 0; i < size; i++) {
		// 修改数组的值
		arr[i] = pow(arr[i], 2);
	}

	for (int e : arr) {
		cout << e << endl;
	}
}

// 入口函数
int main() {

	// 定义一个数组， 常量指定长度
	int arr[5] = { 1, 2, 1, 3, 4 };
	modifyArray(arr);
	return 0;
}

 

函数返回值

• 无返回值 void类型；

void func(int a, int b){
	int c = a + b;
	return;  // 无返回值  return 可以省略
}

• 有返回值

// 返回值的拷贝
string func(const string& name){
	return name;  // 这里返回 name值的拷贝；
}

// 返回 值的引用
const string & func(const string& name){
	return name;  // 这里不会拷贝name的值，而是直接返回对其的引用（高效）
}

 

函数返回数组

• 方式1，指针形式

// 方式1 
int* func(int n, int size) {
	// 动态分配数组，使用new
	int* arr = new int[size];  // 使用完成后 必须delete[] arr 释放
	for (int i = 0; i < size; i++) {
		// 数组赋值
		arr[i] = pow(i, 2); // 取平方
	}
	return arr;  // 返回数组首地址
}

// 入口函数
int main() {
	// 指定数组的长度
	int size = 5;
	int* p = func(10, size); //  调用函数, 返回数组
	// 输出
	for (int i = 0; i < size; i++) {
		cout << *(p + i) << endl; // 指针偏移，并解引用
	}
	delete[] p;// 删除 堆内存 中的空间
	return 0;
}

-方式2，typedef 定义数组类型别名

#include <iostream>
#include "lauf.h" // 包含自定义的头文件
using namespace std;


// typedef 定义类型别名
typedef int lauf[5]; // 声明一个 长度为10的int数组  lauf类型
int arr[5] = { 1, 3, 5, 1, 6 }; // 全局变量 形式
// 定义返回 数组指针 的函数
lauf* func(int n) {
	return &arr;  // 返回数组的地址，如果函数内部int arr[5] = { 1, 3, 5, 1, 6 };初始化数组，则函数执行结束弹栈（数组变量存在栈内存），数组内存被释放，再通过首地址取值就会出错！！！
	// 必须使用static修饰
	// static int arr[5] = {1,3,5,1,6}; // 静态数组对象，放入全局数据区，函数结束弹栈不会释放数组空间;
}

// 入口函数
int main() {

	// 声明 数组指针 变量 
	int(*p)[5] = func(5); //  调用函数, 返回 数组指针
	// 输出
	for (int i = 0; i < 5; i++) {
		cout << *(*p + i) << endl;  // *p 解引用到arr的首地址
	}
	return 0;
}

• 方式3， 数组指针 类型后缀形式

#include <iostream>
#include "lauf.h" // 包含自定义的头文件
using namespace std;


// 后置类型
auto func(int n)->int(*)[5]  {

	//int arr[5] = { 1, 3, 5, 1, 6 };  这种形式，函数执行结束会释放数组空间；
	static int arr[5] = {1,2,5,1,6}; // 静态数组对象，放入全局数据区，函数结束弹栈不会释放数组空间;
	return &arr;  // 返回数组的地址
}

// 入口函数
int main() {

	// 声明 数组指针 变量 
	int(*p)[5] = func(5); //  调用函数, 返回 数组指针
	// 输出
	for (int i = 0; i < 5; i++) {
		cout << *(*p + i) << endl;  // *p 解引用到arr的地址
	}
	return 0;
}