函数

每个 C++ 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。

将多个功能拆分并最终组合，用于调用。实现功能如递归等

简单实例

1
2
3
4
5
6
void 函数名()
{
    函数执行内容
    ...
    return 0;
}
1
2
3
4
5
6
def 函数名():
    函数执行内容
    ...
    return 0

c/c++程序入口为main函数，没有main不能执行，有且只有一个main函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 函数返回两个数中较大的那个数
 
int max(int num1, int num2) 
{
   // 局部变量声明
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

函数的构成

函数声明

1
return_type function_name( parameter list );
函数类型
  • 有返回值
  • int ，float，double，bool …
  • 无返回值
  • void

return_type: 返回类型，表示函数执行后返回的数据类型。例如，int、float、double等，而void表示无需返回结果的函数。

function_name: 函数名，用于标识函数的唯一名称。函数名应该遵循命名规则，以字母或下划线开头，后面可以跟字母、数字或下划线。

parameter list: 参数列表，用于指定函数接收的输入参数。参数列表中的每个参数都由一个类型和一个变量名组成，多个参数之间用逗号分隔。例如，int a, float b, double c。

;: 分号，用于结束函数声明。

函数的调用

创建一个实例程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int sum() //无参函数
{
    int x=10,y=60;
    int s = x + y;
    return s;
}

int sum1(int x,int y)//带参函数
{
    int s;
    s = x + y;
    return s;

}
void sum2()//无返回值
{
    int x = 10,y = 60;
    int s;
    s = x + y;
    cout <<s<<endl;
}
...
int main()
{
   cout<<sum()<<endl;       //调用参数（函数的调用）
   cout<<sum1(10,60)<<endl;  //运行效果相同（）
   //实参传参给形参  10，60传递给函数里面的x，y
   sum2();             //调用函数
   return 0;
}

创建 C++ 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。

当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。

出自菜鸟教程

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>
using namespace std;
 
// 函数声明
int max(int num1, int num2);
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
   int ret;
 
   // 调用函数来获取最大值
   ret = max(a, b);
 
   cout << "Max value is : " << ret << endl;
 
   return 0;
}
 
// 函数返回两个数中较大的那个数
int max(int num1, int num2) 
{
   // 局部变量声明
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

参数

举例此次sum1函数

sum1(10,60) 中的10,60为实参，sum1(int x,int y) 中的int x,int y为形参，单向值传递，实参传递到形参，形参不影响实参

以后的地址传递可以影响

举例：
单向值传递，实参传递到形参，就像家人（实参）给你（形参，函数内）打的生活费（参数），你手上的资金不会改变（实参）

地址传递，就像家人（实参）给你（形参）一个银行账户（地址），你对账户内的改变会影响（实参）

地址传递是一种将实际参数的地址传递到函数中的参数传递方式。在函数中对参数进行的修改，将影响到实际参数。这是因为形参接收到的是实参的地址，即指向实参的存储单元，形参和实参占用相同的存储单元。例如，如果我们定义了一个指针类型的形参，然后将实参的地址传递给这个形参，那么在函数内部对形参所进行的修改，将影响到实际参数的值。

调用类型 描述
传值调用 该方法把参数的实际值赋值给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。
指针调用 该方法把参数的地址赋值给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
引用调用 该方法把参数的引用赋值给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
地址传参

地址传递是C++中的一种参数传递方式，它允许函数直接修改实参的值。当我们使用地址传递时，函数会接收到实参的内存地址，而不是实参的值。因此，在函数内部对实参进行的任何修改都会影响到实参本身。

下面是一个使用地址传递的C++示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;

void modify(int *num) {
    *num = 100;
}

int main() {
    int a = 50;
    cout << "Before calling modify function: " << a << endl;
    modify(&a);
    cout << "After calling modify function: " << a << endl;
    return 0;
}

在这个示例中，我们定义了一个名为modify的函数，它接受一个指向整数的指针作为参数。在main函数中，我们将变量a的地址传递给modify函数。在modify函数内部，我们通过解引用指针来修改实参的值。因此，当我们调用modify(&a)后，实参a的值被修改为100。

函数重载 overloading function

  • 函数名相同
  • 参数不同
  • 参数类型不同
  • 参数个数不同
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int min_num(int a,int b)
{    return a<b?a:b;  }

float min_num(float a,float b)
{    return a<b?a:b;  }

int min_num(int a,int b,int c)
{    
    return min_num(min_num(a,b),c);
}

int main()
{
    min_num(a,b)//a,b参数的类型若为float则调用float min_num
    
    min_num(int a,int b,int c)//三个参数则会调用 min_num(int a,int b,int c)
    
}

参数默认值

默认赋值只能自右向左。

若函数没有被传入参数，则使用默认参数

定义参数时viod minnum(int ,int =0,int =5)自右向左

调用函数时minnum(10,20);自左向右依次赋值给a，b

c使用默认值

1
2
3
4
5
6
7
8
9
10
11
12
viod minnum(int ,int =0,int =5);
int main()
{
    minnum(10,20);
    minnum(10);
}

viod minnum(int a,int b,int c)
{
    cout<<a<<b<<m<<endl

}

内联函数

简单的短函数编译到主函数内

没有循环和switch的函数

inline int function

将函数直接编译到主函数内，可以加快执行速度

静态局部变量

static声明

函数中的局部变量不会随函数调用结束而清除

在C++中，static int a 是一个静态局部变量。它的作用域仅限于定义它的函数或代码块。当程序执行到这个变量时，它会在内存中分配一个固定大小的存储空间，用于存储整数值。静态局部变量的生命周期与程序的运行时间相同，即在整个程序运行期间，它都存在。

1
2
3
4
5
6
7
void f()
{
    static int a;
}
int main()
{
}

访问全局变量

在局部变量中使用::a访问全局变量

1
2
3
4
5
6
7
8
int a = 10; //全局变量

void func() {
    int a = 20; //局部变量
    ::a; //访问全局变量a
}

::a is 10

变量的引用

int& a 是一个引用类型，表示一个整数变量的引用。在C++中，引用是一种别名，它允许你通过引用来访问和修改另一个变量的值。使用引用可以避免不必要的拷贝操作，提高程序的性能。

引用是C++中的一种特殊类型，它提供了一种方式来直接访问和操作其他变量的值。引用是一个已存在变量的别名，通过引用可以间接地访问该变量的值，而不需要复制整个变量。

在C++中，声明一个引用需要使用&运算符，后面跟着要引用的变量的名称。例如，int& a表示一个整数类型的引用，名为a。

引用与指针有些类似，但有一些重要的区别：

  • 引用必须在声明时初始化，并且之后不能再改变指向的变量；而指针可以在任何时候改变指向的变量。
  • 引用没有空引用的概念，即必须始终指向一个实际存在的变量；而指针可以为空。
  • 引用使用.运算符来访问其指向的变量的值，而指针使用->运算符。
  • 引用传递参数时，实际上是将实参的地址传递给形参，因此对形参的修改也会影响到实参；而指针传递参数时，是将实参的值（即地址）传递给形参，对形参的修改不会影响实参。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5;
    int y = 10;
    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    swap(x, y); // 通过引用交换x和y的值
    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;
    return 0;
}
1
2
Before swap: x = 5, y = 10
After swap: x = 10, y = 5
引用与指针

在C++中，"地址的引用"通常被理解为对指针所指向的变量的别名。具体来说，当我们创建一个指针变量时，例如 int* p = &val;，指针变量p就包含了另一个变量val的地址。此时，我们可以通过 *p来访问或修改指针所指向的变量的值。

然而，C++还提供了一种更为简洁的方式，即引用(reference)。引用是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。例如，我们可以声明一个整数类型的引用，如 int& a = val;，此后a就成为了val的别名，对a的任何操作都会直接影响到val。

总的来说，无论是使用指针还是引用，都可以实现对变量的间接访问。但需要注意的是，指针和引用在使用上有一些重要的区别：指针是一个包含了另一个变量地址的变量，而引用则是一个已经初始化并指向某个变量的别名。另外，一旦引用被初始化为一个变量后，就不能再改变它指向另一个变量。

  • ps."一旦引用被初始化为一个变量后，就不能再改变它指向另一个变量"的意思是，在C++中，一旦我们声明并初始化了一个引用，例如 int& a = val;，那么这个引用（这里用 a 表示）就会始终指向 val 变量，并且无法更改使其指向其他变量。换句话说，引用的生命周期是与它最初指向的变量共存亡的。

  • 这是因为引用实际上就是目标变量的一个别名。换句话说，引用和它所引用的变量共享同一块内存空间。因此，如果我们试图让引用指向另一个变量，那将会导致意想不到的结果，因为那个新的变量并没有与旧的变量共享同一块内存空间。

引用即给原来的变量取了一个小名，这个小名只能指向一个变量，不能再给别人，小名和大名都是这个人，无论怎么变，大小名都相同。

字符串截取

<string><iostream>
c++substr(起始位置,截取长度)
pythonstring[i:i+1]