One 、 Understanding of relevant terms

1. What is a function

yes Subroutines , Compared to other codes , have Relative independence .

Tend to have Input parameters And there are Return value .

2.C Functions in language

Ι. Library function

（1） Common library functions

·IO function

· String manipulation functions

· Character manipulation functions

· Memory manipulation function

· Time / Date function

· Mathematical functions

· Other library functions

（2） Be careful

1. Use library functions , Must contain #include Corresponding header file .

2. Use document learning library functions —— Focus on two points 【 return type , Parameter type 】

3. Common ways to learn library functions

①C/C++ Language website 【 On-line 】

②MSDN【 offline 】

Π. Custom function

A function with specific functions encapsulated by programmers according to their own needs .

In general , Wide applicability 、 Strong independence .

There are three main points to consider Function name 、 return type 、 Function parameter .

3. Function parameter

（1） The actual parameter

The parameters that are actually passed to the function , It's called the actual parameter .

The argument can be ： Constant 、 Variable 、 expression 、 Functions, etc .

To make a long story short , Is a variable or constant with a definite value .

（2） Formal parameters

Formal parameters refer to the variables in brackets after the function name , Because formal parameters are only instantiated when the function is called （ Allocate memory units ）, So it's called formal parameter .

※ Be careful

1. After the formal parameter is instantiated, it is actually equivalent to a temporary copy of the argument .

2. Formal parameters are automatically destroyed when the function call is completed

【 Review the process of creating and destroying function stack frames 】

4. Function call

（1） Value transfer call

The actual parameter is Non address .

After call , No effect on arguments .

Be careful ： Passing the array name is essentially passing the address of the first element of the array , It belongs to address calling .

（2） Address call

The actual parameter is Address .

After call , Will affect the arguments .

5. Nested calls and chained access to functions

（1） Nested calls

A nested call is a function that calls another function .

Functions can be called nested , But you can't nest definitions .

（2） Chained access

Chained access means that the parameter of one function is the return value of another function .

6. Function declaration and definition

（1） Function declaration

1. Tell the compiler that there is a function called , What are the parameters , What is the return type . But does it exist , Function declarations do not determine .

2. The declaration of a function usually precedes the use of the function . To meet the Declare before use .

3. The declaration of a function is usually placed in the header file

（2） Function definition

The definition of a function refers to the concrete implementation of a function .

7. Function recursion

（1） What is recursion

To put it bluntly , Recursion is a programming skill of calling functions by themselves .

（2） There are two necessary conditions for recursion

The two conditions actually correspond to the two stages of recursion .

① There are restrictions , When this constraint is met , Recursion doesn't continue .—— Delivery stage

② After every recursive call Getting closer to This restriction —— Changes in the implementation process .—— Return stage

（3） Advantages and disadvantages of recursion and iteration

Iteration can be simply understood as a cycle for the time being .

The connection between the two ：1） There must be iterations in recursion , But iterations don't have to be recursive , Most of them can switch to each other .

2） Can be used iteratively without recursion , Call function recursively , Waste space , And recursion is too deep to cause stack overflow ./ relative /

Reference resources

Two 、 Error prone example demonstration

1. Nested calls and chained access to functions

Nested call instances

#include <stdio.h>
void new_line()
{
    
	printf("hehe\n");// Nested call printf function 
}
void three_line()
{
    
    int i = 0;
    for(i=0; i<3; i++)
    {
    
        new_line();// Nested call new_line function 
    }
}
int main()
{
    
     three_line();// Nested call three_line function 
     return 0; 
}

Chain access instance

// example 1
#include <stdio.h>
#include <string.h>
int main()
{
    
    char arr[20] = "hello";
    int ret = strlen(strcat(arr,"bit")); //strcat Return the array name after splicing 
    printf("%d\n", ret);
    return 0; 
}

// example 2
#include <stdio.h>
int main()
{
    
    printf("%d", printf("%d", printf("%d", 43)));
    // The result is 4321
    // notes ：printf The return value of the function is the number of characters printed on the screen 
    return 0; 
}

2. Function declaration and definition

The header file

test.h**** The content of

Place the declaration of the function

#ifndef __TEST_H__
#define __TEST_H__
// Declaration of functions 
int Add(int x, int y);
#endif //__TEST_H__

Source file

test.c**** The content of

Implementation of placement function

#include "test.h"
// function Add The implementation of the 
int Add(int x, int y) {
    
 return x+y; }

3. Function recursion

1) Print each bit of the unsigned number in sequence

#include <stdio.h>
void print(int n) 
{
    
    if(n>9)
    {
    
        print(n/10);
    }
    printf("%d ", n%10);
}
int main()
{
    
    int num = 1234;
    print(num);
    return 0; 
}

2） Use recursion and do not create temporary variables to implement strlen

#incude <stdio.h>
int Strlen(const char*str)
{
    
    if(*str == '\0')
        return 0;
    else
        return 1+Strlen(str+1);
}
int main()
{
    
    char *p = "abcdef";
    int len = Strlen(p);
    printf("%d\n", len);
    return 0; 
}

Recursive iteration reference