本文主要是介绍C&C++学习心法06函数，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

函数

概述

• 函数分类
  C 程序是由函数组成的，我们写的代码都是由主函数 main()开始执行的。函数是 C 程序的基本模块，是用于完成特定任务的程序代码单元。

从函数定义的角度看，函数可分为系统函数和用户定义函数两种：

• 系统函数，即库函数：这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用它们，如我们常用的打印函数printf()。
• 用户定义函数：用以解决用户的专门需要。

函数的作用: 函数的使用可以省去重复代码的编写，降低代码重复率

函数定义格式

函数定义的一般形式：

返回类型 函数名(形式参数列表)
{
	数据定义部分;
	执行语句部分;
}

// 求两数的最大值
int max(int a, int b)
{
	if (a > b){
		return a;
	}
	else{
		return b;
	}
}

int main()
{
	// 操作1 ……
	// ……
	int a1 = 10, b1 = 20, c1 = 0;
	c1 = max(a1, b1); // 调用max()

	// 操作2 ……
	// ……
	int a2 = 11, b2 = 21, c2 = 0;
	c2 = max(a2, b2); // 调用max()

	// ……

	return 0;
}

• 函数可以让程序更加模块化，从而有利于程序的阅读，修改和完善

假如我们编写一个实现以下功能的程序：读入一行数字；对数字进行排序；找到它们的平均值；打印出一个柱状图。如果我们把这些操作直接写在main()里，这样可能会给用户感觉代码会有点凌乱。但，假如我们使用函数，这样可以让程序更加清晰、模块化：

#include <stdio.h>

int main()
{
	float list[50];

	// 这里只是举例，函数还没有实现
	readlist(list, 50);
	sort(list, 50);
	average(list, 50);
	bargraph(list, 50);

	return 0;
}

这里我们可以这么理解，程序就像公司，公司是由部门组成的，这个部门就类似于C程序的函数。默认情况下，公司就是一个大部门( 只有一个部门的情况下 )，相当于C程序的main()函数。如果公司比较小( 程序比较小 )，因为任务少而简单，一个部门即可( main()函数 )胜任。但是，如果这个公司很大( 大型应用程序 )，任务多而杂，如果只是一个部门管理( 相当于没有部门，没有分工 )，我们可想而知，公司管理、运营起来会有多混乱，不是说这样不可以运营，只是这样不完美而已，如果根据公司要求分成一个个部门( 根据功能封装一个一个函数 )，招聘由行政部门负责，研发由技术部门负责等，这样就可以分工明确，结构清晰，方便管理，各部门之间还可以相互协调。

函数的调用：产生随机数

当调用函数时，需要关心5要素：

• 头文件：包含指定的头文件
• 函数名字：函数名字必须和头文件声明的名字一样
• 功能：需要知道此函数能干嘛后才调用
• 参数：参数类型要匹配
• 返回值：根据需要接收返回值

#include <time.h>
time_t time(time_t *t);
功能：获取当前系统时间
参数：常设置为NULL
返回值：当前系统时间, time_t 相当于long类型，单位为毫秒

#include <stdlib.h>
void srand(unsigned int seed);
功能：用来设置rand()产生随机数时的随机种子
参数：如果每次seed相等，rand()产生随机数相等
返回值：无

#include <stdlib.h>
int rand(void);
功能：返回一个随机数值
参数：无
返回值：随机数
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main()
{
	time_t tm = time(NULL);//得到系统时间
	srand((unsigned int)tm);//随机种子只需要设置一次即可

	int r = rand();
	printf("r = %d\n", r);

	return 0;
}

函数名字、形参、函数体、返回值

1. 函数名
   理论上是可以随意起名字，最好起的名字见名知意，应该让用户看到这个函数名字就知道这个函数的功能。注意，函数名的后面有个圆换号()，代表这个为函数，不是普通的变量名。

2. 形参列表
   在定义函数时指定的形参，在未出现函数调用时，它们并不占内存中的存储单元，因此称它们是形式参数或虚拟参数，简称形参，表示它们并不是实际存在的数据，所以，形参里的变量不能赋值

void max(int a = 10, int b = 20) // error, 形参不能赋值
{
}

在定义函数时指定的形参，必须是，类型+变量的形式：

/1: right, 类型+变量
void max(int a, int b)
{
}

//2: error, 只有类型，没有变量
void max(int, int)
{
}

//3: error, 只有变量，没有类型
int a, int b;
void max(a, b)
{
}

在定义函数时指定的形参，可有可无，根据函数的需要来设计，如果没有形参，圆括号内容为空，或写一个void关键字：

// 没形参， 圆括号内容为空
void max()
{
}

// 没形参， 圆括号内容为void关键字
void max(void)
{
}

3. 函数体
   花括号{ }里的内容即为函数体的内容，这里为函数功能实现的过程，这和以前的写代码没太大区别，以前我们把代码写在main()函数里，现在只是把这些写到别的函数里。

4. 返回值
   函数的返回值是通过函数中的return语句获得的，return后面的值也可以是一个表达式。

a)尽量保证return语句中表达式的值和函数返回类型是同一类型

int max() // 函数的返回值为int类型
{
	int a = 10;
	return a;// 返回值a为int类型，函数返回类型也是int，匹配
}

b)如果函数返回的类型和return语句中表达式的值不一致，则以函数返回类型为准，即函数返回类型决定返回值的类型。对数值型数据，可以自动进行类型转换。

double max() // 函数的返回值为double类型
{
	int a = 10;
	return a;// 返回值a为int类型，它会转为double类型再返回
}

注意：如果函数返回的类型和return语句中表达式的值不一致，而它又无法自动进行类型转换，程序则会报错。

c)return语句的另一个作用为中断return所在的执行函数，类似于break中断循环、switch语句一样。

int max()
{
	return 1;// 执行到，函数已经被中断，所以下面的return 2无法被执行到
	return 2;// 没有执行
}

d)如果函数带返回值，return后面必须跟着一个值，如果函数没有返回值，函数名字的前面必须写一个void关键字，这时候，我们写代码时也可以通过return中断函数(也可以不用)，只是这时，return后面不带内容( 分号“；”除外)。

void max()// 最好要有void关键字
{
	return; // 中断函数，这个可有可无
}

函数的调用

定义函数后，我们需要调用此函数才能执行到这个函数里的代码段。这和main()函数不一样，main()为编译器设定好自动调用的主函数，无需人为调用，我们都是在main()函数里调用别的函数，一个 C 程序里有且只有一个main()函数。

• 函数执行流程

#include <stdio.h>

void print_test()
{
	printf("this is for test\n");
}

int main()
{
	print_test();	// print_test函数的调用

	return 0;
}

1. 进入main()函数
2. 调用print_test()函数：
   a. 它会在main()函数的前寻找有没有一个名字叫“print_test”的函数定义；
   b. 如果找到，接着检查函数的参数，这里调用函数时没有传参，函数定义也没有形参，参数类型匹配；
   c. 开始执行print_test()函数，这时候，main()函数里面的执行会阻塞( 停 )在print_test()这一行代码，等待print_test()函数的执行。
3. print_test()函数执行完( 这里打印一句话 )，main()才会继续往下执行，执行到return 0, 程序执行完毕。

• 函数的形参和实参

1. 形参出现在函数定义中，在整个函数体内都可以使用，离开该函数则不能使用。
2. 实参出现在主调函数中，进入被调函数后，实参也不能使用。
3. 实参变量对形参变量的数据传递是“值传递”，即单向传递，只由实参传给形参，而不能由形参传回来给实参。
4. 在调用函数时，编译系统临时给形参分配存储单元。调用结束后，形参单元被释放。
5. 实参单元与形参单元是不同的单元。调用结束后，形参单元被释放，函数调用结束返回主调函数后则不能再使用该形参变量。实参单元仍保留并维持原值。因此，在执行一个被调用函数时，形参的值如果发生改变，并不会改变主调函数中实参的值。

• 无参函数调用
  如果是调用无参函数，则不能加上“实参”，但括号不能省略。

// 函数的定义
void test()
{
}

int main()
{
	// 函数的调用
	test();	// right, 圆括号()不能省略
	test(250); // error, 函数定义时没有参数

return 0;
}

• 有参函数调用
  a)如果实参表列包含多个实参，则各参数间用逗号隔开。

// 函数的定义
void test(int a, int b)
{
}

int main()
{
	int p = 10, q = 20;
	test(p, q);	// 函数的调用

	return 0;
}

b)实参与形参的个数应相等，类型应匹配(相同或赋值兼容)。实参与形参按顺序对应，一对一地传递数据。
c)实参可以是常量、变量或表达式，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。所以，这里的变量是在圆括号( )外面定义好、赋好值的变量。

// 函数的定义
void test(int a, int b)
{
}

int main()
{
	// 函数的调用
	int p = 10, q = 20;
	test(p, q);	// right
	test(11, 30 - 10); // right

	test(int a, int b); // error, 不应该在圆括号里定义变量

	return 0;
}

函数返回值
a）如果函数定义没有返回值，函数调用时不能写void关键字，调用函数时也不能接收函数的返回值。

// 函数的定义
void test()
{
}

int main()
{
	// 函数的调用
	test(); // right
	void test(); // error, void关键字只能出现在定义，不可能出现在调用的地方
	int a = test();	// error, 函数定义根本就没有返回值

	return 0;
}

b）如果函数定义有返回值，这个返回值我们根据用户需要可用可不用，但是，假如我们需要使用这个函数返回值，我们需要定义一个匹配类型的变量来接收。

// 函数的定义, 返回值为int类型
int test()
{
}

int main()
{
	// 函数的调用
	int a = test(); // right, a为int类型
	int b;
	b = test();	// right, 和上面等级

	char *p = test(); // 虽然调用成功没有意义, p为char *, 函数返回值为int, 类型不匹配

	// error, 必须定义一个匹配类型的变量来接收返回值
	// int只是类型，没有定义变量
	int = test();	
	
	// error, 必须定义一个匹配类型的变量来接收返回值
	// int只是类型，没有定义变量
	int test();
	
	return 0;
}

函数的声明

如果使用用户自己定义的函数，而该函数与调用它的函数（即主调函数）不在同一文件中，或者函数定义的位置在主调函数之后，则必须在调用此函数之前对被调用的函数作声明。

所谓函数声明，就是在函数尚在未定义的情况下，事先将该函数的有关信息通知编译系统，相当于告诉编译器，函数在后面定义，以便使编译能正常进行。

注意：一个函数只能被定义一次，但可以声明多次。

#include <stdio.h>

int max(int x, int y); // 函数的声明，分号不能省略
// int max(int, int); // 另一种方式

int main()
{
	int a = 10, b = 25, num_max = 0;
	num_max = max(a, b); // 函数的调用

	printf("num_max = %d\n", num_max);

	return 0;
}

// 函数的定义
int max(int x, int y)
{
	return x > y ? x : y;
}

函数定义和声明的区别：
1）定义是指对函数功能的确立，包括指定函数名、函数类型、形参及其类型、函数体等，它是一个完整的、独立的函数单位。
2）声明的作用则是把函数的名字、函数类型以及形参的个数、类型和顺序(注意，不包括函数体)通知编译系统，以便在对包含函数调用的语句进行编译时，据此对其进行对照检查（例如函数名是否正确，实参与形参的类型和个数是否一致）。

main函数与exit函数

在main函数中调用exit和return结果是一样的，但在子函数中调用return只是代表子函数终止了，在子函数中调用exit，那么程序终止。

#include <stdio.h>
#include <stdlib.h>

void fun()
{
	printf("fun\n");
	//return;
	exit(0);
}

int main()
{
	fun();
	while (1);

	return 0;
}

多文件(分文件)编程

分文件编程

1. 把函数声明放在头文件xxx.h中，在主函数中包含相应头文件
2. 在头文件对应的xxx.c中实现xxx.h声明的函数
   

• 防止头文件重复包含
  当一个项目比较大时，往往都是分文件，这时候有可能不小心把同一个头文件 include 多次，或者头文件嵌套包含。
  a.h 中包含 b.h ：

#include "b.h"

b.h 中包含 a.h：

#include "a.h"

main.c 中使用其中头文件：

#include "a.h"

int main()
{
	return 0;
}

编译上面的例子，会出现如下错误：

为了避免同一个文件被include多次，C/C++中有两种方式，一种是 #ifndef 方式，一种是 #pragma once 方式。
方法一：

#ifndef __SOMEFILE_H__
#define __SOMEFILE_H__

// 声明语句

#endif

方法二：

#pragma once

// 声明语句

递归

函数递归 ： 函数自己调用自己
1 ~ num 累加和

#include <iostream>
using namespace std;
// 函数递归 ： 函数自己调用自己
// 好处: 会让复杂的逻辑使用递归函数看起来更简洁
// 语义
int addSum(int n){
    if ( n <= 1)
        return 1;
    return addSum(n-1) + n;
}
int mulCal(int n){
    if(n<=1)
        return 1;
    return mulCal(n-1)*n;
}
int main() {
    cout<< addSum(100)<<endl;
    cout<< addSum(5)<<endl;
    cout<< mulCal(5)<<endl;
    cout<< mulCal(10)<<endl;
    cout<< mulCal(2)<<endl;
    cout<< mulCal(3)<<endl;
}
//  100*99*98.....   n!

斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家莱昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）

#include <iostream>
using namespace std;
// 1、1、2、3、5、8、13、21、34
int fibo(int n){
    if (n <=2)
        return 1;
    return fibo(n-1) + fibo(n-2);
}

int fibo2(int n){
    if (n == 2)
        return 1;
    if (n == 1)
        return 0;
    return fibo2(n-1) + fibo2(n-2);
}
//0、 1、1、2、3、5、8、13、21、34 fibo2

int main() {
    cout<<fibo(8)<<endl;
    cout<<fibo(6)<<endl;
    cout<<fibo(4)<<endl;
    cout<<fibo(2)<<endl;
    cout<<fibo(1)<<endl;
    cout<<fibo2(3)<<endl;
    cout<<fibo2(4)<<endl;

}

#include <iostream>
using namespace std;
int sum(int arr[], int size){
    // arr[l, len)这个区间的和等于 arr[l]  +  arrl后面的
    if (size == 0)
        return 0;          //如果数组为空，返回0 
    else if (size == 1)
        return arr[size-1]; // 如果数组只有一个元素，返回该数组元素
    else
        return arr[size - 1] + sum(arr, size-1);      
    //数组最后索引的数值和递归调用sum方法 
}

int main(){
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int len = sizeof(arr)/sizeof(arr[0]);

    cout <<sum(arr, len) << endl;


}

内联函数

声明方式是返回值前加inline关键字, 目的是对一些函数体不是很大, 但又频繁被调用而且想要很高的效率的函数来进行声明

#include <iostream>
using namespace std;
inline int cube(int x){
    return x*x*x;
}

int main()
{
    int result;
    result = cube(2);
    cout<<"2*2*2 = " << result<<endl;
    result = cube(3);
    cout<<"3*3*3 = " << result<<endl;
    return 0;
}

函数的重载 overload

什么是重载? 同名不同参
同名是函数名相同, 不同参是指 函数的参数类型和个数不相同, 这里与返回值没啥关系

#include <iostream>
using namespace std;
int add(int x, int y){
    return x + y;
}
float add(float x, float y){
    return x + y;
}
int add(int x, int y, int z){
    return x + y + z;
}
int main()
{
    float a = 10.6f;
    float b = 8.7f;
    cout<< add(10, 8)<< endl;
    cout<< add(10, 8, 33)<< endl;
    float  c = add(a, b);
    cout<< c << endl;

}

数组作为函数的参数

• 数组中元素中作为函数的参数
  案例: 统计数组对应元素中大于/小于/等于的个数

#include <iostream>
using namespace std;
int large(int x, int y){
    if (x > y)
        return 1;
    else if (x < y)
        return -1;
    else
        return 0;
}
int main(){
    int a[4] = {2223, 166 , 33 , 55};
    int b[4] = {323, 166 , 3 , 5335};
    int g = 0,  e = 0, l = 0;
    for (int i = 0; i < 4; ++i) {
        int flag = large(a[i], b[i]);
        if (flag == 1)
            g++;
        else if (flag == 0)
            e++;
        else
            l++;
    }
    cout<<" a[i] > b[i] counts "<<g<<endl;
    cout<<" a[i] = b[i] counts "<<e<<endl;
    cout<<" a[i] < b[i] counts "<<l<<endl;

}

案例

• 编写一个可以控制范围和个数的生成数组函数
• 编写打印数组的函数
• 对生成数组传入冒泡排序函数进行排序
• 对生成数组传入选择排序函数进行排序

#include <iostream>
#include <ctime>
using namespace std;
//- 编写一个可以控制范围和个数的生成数组函数
//- 对生成数组传入冒泡排序函数进行排序
//- 对生成数组传入选择排序函数进行排序
/*
 * arr[] 返回数组
 * a 生成随机数的下限
 * b 生成随机数的上限
 * n 是生成个数
 */
void genrateArray(int arr[], int a, int b, int n){
    srand((unsigned int )time(NULL));
    for (int i = 0; i < n; ++i) {
        //  生成a~b 之间的一个随机整数
        arr[i] = rand() % (b-a+1)+ a;
    }
}
void printArray(int arr[], int len){
    cout << "[";
    for (int i = 0; i < len; ++i) {
       if (i==len-1)
           cout << arr[i] << "]";
       else
           cout << arr[i] << ", ";
    }
    cout <<  endl;
}
void bubbleSort(int arr[], int len){
    for (int i = 0; i < len -1; ++i) {
        for (int j = len-1; j > i; --j) {
            if (arr[j-1] > arr[j]){
                int temp = arr[j-1];
                arr[j-1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}
void selectSort(int arr[], int len){

    for (int i = 0; i < len - 1; ++i) {
        int minIndex = i;
        for (int j = i; j < len; ++j) {
            if (arr[j] < arr[minIndex]){
                minIndex = j;
            }
        }
        // 优化
        if (minIndex!=i){
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}
int main(){
    const int N = 10;
    int arr[N];
    genrateArray(arr, 1, 100, N);
    cout<<"selectSort Before"<< endl;
    printArray(arr, N);
    selectSort(arr, N);
    cout<<"selectSort After"<< endl;
    printArray(arr, N);
    cout<<"bubbleSort Before"<< endl;
    genrateArray(arr, 1, 1000, N);
    printArray(arr, N);
    cout<<"bubbleSort After"<< endl;
    bubbleSort(arr, N);
    printArray(arr, N);
}

反转数组

#include <iostream>
using namespace std;
void inverse(int a[], int len){
    for (int i = 0; i < len/2; ++i) {
        int temp = a[i];
        a[i] = a[len -1 -i];
        a[len -1 -i] = temp;
    }
}
int main()
{
    int a[9] = {6, 7, 2, 5, 4, 3, 6, 1, 9};
    // 反转数组
    inverse(a, 9);
    // 输出数组
    for (int i = 0; i < 9; ++i) {
        cout << a[i]<<"\t";
    }

}

作用域

块作用域 {} 隔离代码的
在一个函数内部定义的变量或者在一个块中定义的变量称为局部变量, 声明周期在块中有效

#include <iostream>
using namespace std;
int main()
{
    int a=1, b=2;

    ++a;
    ++b;
    {
        int b=4, c;

        c=a+b;       //c只能在该复合语句内使用
        cout<<"a="<<a<<", "<<"b="<<b<<", "<<"c="<<c<<endl;
    }
    cout<<"a="<<a<<", "<<"b="<<b<<endl;

}

24623
文件作用域
在函数外面定义的变量或者用extern声明的变量
, 文件是c++的编译单位, 在所有函数外定义的标识符具有文件作用域, 作用域从定义点开始一直到本文件结束

#include <iostream>

int i = 10; // 文件作用域
int main()
{
    // 在内部操作全局变量 :: 符合
    int i, j = 5;
    i=20;             //访问局部变量i
    ::i=::i+4;          //访问全局变量i
    j=::i+i;           //访问全局变量i和局部变量i、j
    std::cout<<"::i="<<::i<<std::endl; // 14
    std::cout<<"i="<<i<<std::endl; // 20
    std::cout<<"j="<<j<<std::endl; //  34

}

存储类别

局部变量的存储类别
c++中 局部变量的存储为

• auto 默认的不用写, 若没有明确的赋值, 初始值是不确定的
• static 静态局部变量被分配到静态存储中(具有记忆功能)

#include <iostream>
using namespace std;

int fun(int x) {
    static int a = 3;
    a += x;
    return a;
}

int main() {
    int k = 2, m = 1, n;
    n = fun(k);
    cout << "first: n=" << n << endl;  // 5
    n = fun(m);
    cout << "second: n=" << n << endl; // 6
}


局部变量和全局变量

这篇关于C&C++学习心法06函数的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！