C++ 教程 - 03 函数篇

发布时间:2023年12月18日

函数定义

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

  • 定义函数格式
    类型 函数名(形参类型 形参名称,…){ 函数体; return 类型值;}

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

  • 函数定义代码

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

函数案例

  • 2 10 {2^{10}} 210 的值;->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 f(n) = f(n-1) + f(n-2);n>= 2 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;
}

?

文章来源:https://blog.csdn.net/weixin_45228198/article/details/134961093
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。