C语言（库函数，自定义函数，形参实参，嵌套，调用链式）

#strcpy 字符串拷贝
C语言 strcpy() 函数用于对字符串进行复制（拷贝）。
语法:char* strcpy(char* strDestination, const char* strSource);
参数说明：
strDestination：目的字符串。
strSource：源字符串。

strcpy() 会把 strSource 指向的字符串复制到 strDestination。

必须保证 strDestination 足够大，能够容纳下 strSource，否则会导致溢出错误。

返回值：目的字符串，也即 strDestination。

int main()
{
    char arr1[20]="xxxxxxxxx";
    char arr2[]="hello";
    strcpy(arr1,arr2);
    printf("%s\n,arr1");
    return 0;
}

int main()
{
    char arr1[20]="xxxxxxxxx";
    char arr2[]="hello";
    strcpy(arr1,arr2);
    printf("%s\n,arr1");
    return 0;
}

#include<stdio.h>
int main()
{
    char arr1[]="hello bit";
    int n=5;
    char *arr2=memset(arr1,'x',n);
    printf("%s\n",arr2);
    return 0;
}

int main()
{
    int arr[10]={0};
    memset(arr,1,5*sizeof(int));
    printf("%d\n",arr);
    return 0;
}

#自定义函数
函数的组成:
ret_type fun_name(para1, * )
{
    statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1 函数参数
 

#include<stdio.h>
int get_max(int x,int y)
{
    return(x > y ? x : y);
}

int main()
{
    int a=0;
    int b=0;
    scanf("%d%d",&a,&b);

    //求两个函数的较大值
    int max=get_max(a,b);
    printf("max=%d\n",max);
    return 0;
}

#写一个函数来实现交换两个数的内容
使用指针前

#include<stdio.h>
void Swap(int x,int y)
{
    int z=0;
    z=x;
    x=y;
    y=z
}
int main()
{
    int a=10;
    int b=20;
    printf("交换前:a=%d b=%d\n",a,b);
    //函数
    Swap(&a,&b);
    //实参a和b，传给形参x,y的时候，形参将是实参的一份临时拷贝
    //改变形参变量x,y,是不会影响实参a和b的。
    printf("交换后:a=%d b=%d\n",a,b);
    return 0;
}

使用指针后

#include<stdio.h>
void Swap(int *px,int *py)
{
    int z=0;
    z=*px;
    *px=*py;
    *py=z;
}
int main()
{
    int a=10;
    int b=20;
    printf("交换前:a=%d b=%d\n",a,b);
    //函数
    Swap(&a,&b);
    printf("交换后:a=%d b=%d\n",a,b);
    return 0;
}

#形参和实参
C语言函数的参数会出现在两个地方，分别是函数定义处和函数调用处，这两个地方的参数是有区别的。
形参（形式参数）
在函数定义中出现的参数可以看做是一个占位符，它没有数据，只能等到函数被调用时接收传递进来的数据，所以称为形式参数，简称形参。
实参（实际参数）
函数被调用时给出的参数包含了实实在在的数据，会被函数内部的代码使用，所以称为实际参数，简称实参。

形参和实参的功能是传递数据，发生函数调用时，实参的值会传递给形参。

形参和实参的区别和联系
1) 形参变量只有在函数被调用时才会分配内存，调用结束后，立刻释放内存，所以形参变量只有在函数内部有效，不能在函数外部使用。

2) 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的数据，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参，所以应该提前用赋值、输入等办法使实参获得确定值。

3) 实参和形参在数量上、类型上、顺序上必须严格一致，否则会发生“类型不匹配”的错误。当然，如果能够进行自动类型转换，或者进行了强制类型转换，那么实参类型也可以不同于形参类型。

4) 函数调用中发生的数据传递是单向的，只能把实参的值传递给形参，而不能把形参的值反向地传递给实参；换句话说，一旦完成数据的传递，实参和形参就再也没有瓜葛了，所以，在函数调用过程中，形参的值发生改变并不会影响实参。

#函数的调用
函数中传值与传址的概念：

1.传值：传值，实际是把实参的值赋值给行参，相当于copy。那么对行参的修改，不会影响实参的值 。
2.传址： 实际是传值的一种特殊方式，只是他传递的是地址，不是普通的赋值，那么传地址以后，实参和行参都指向同一个对象，因此对形参的修改会影响到实参。

#用函数实现100-200的素数
如果是素数   返回1
如果不是素数 返回0
判断n是否为素数

#include<stdio.h>
#include<math.h>
int is_prime(int n)
{
    //试除法
    //2~n-1
    //2~sqrt(n)
    int j = 0;
    for(j=2;j<=sqrt(n);j++)
    {
        if(n%j == 0)
            return 0;
    }
    return 1;
}
int main()
{
    //100-200之间的素数
    int i=0;
    int count=0;
    for(i=100;i<=200;i++)
    {
        //判断i是否为素数
        is_prime(i);
        if(is_prime(i)==1)
        {
            printf("%d",i);
            count++;
        }
    }
    printf("\n素数一共有%d\n",count);
    return 0;
}

#用函数判断一个年是否为闰年(1000-2000)

#include<stdio.h>
int is_leap_year(int x)
{
    return ((x%4==0&&x%100!=0)||(x%400==0));

}

int main()
{
    int y=0;
    int count=0;
    for(y=1000;y<=2000;y++)
    {
        is_leap_year(y);
        if(is_leap_year(y)==1)
        {
            printf("%d ",y);
            count++;
        }
    }
    printf("\ncount=%d\n",count);
    return 0;
}

#用函数实现一个有序整形数组的二分查找

#include<stdio.h>
int binary_search(int arr[],int k, int size)
{
    int left=0;
    int right=size-1;

    while(left<=right)
    {
        int mid=(left+right)/2;
        if(k>arr[mid])
        {
            left=mid+1;
        }
        else if(k<arr[mid])
        {
            right=mid-1;
        }
        else
            return mid;
    }
    return -1;
}
int main()
{
    int arr[10]={1,2,3,4,5,6,7,8,9,10,11,12,13};
    int k=6;
    int size=sizeof(arr)/sizeof(arr[0]);
    int ret=binary_search(arr,k,size);
    if(ret==-1)
        printf("找不到\n");
    else
        printf("找到了，下标是:%d\n",ret);
    return 0;
}

#设计一个函数，每次调用时给num加1.

#include<stdio.h>
void Add(int *p)
{
    *p = *p +1;
}
int main()
{
    int num=0;
    Add(&num);
    printf("num=%d\n",num);
    Add(&num);
    printf("num=%d\n",num);
    Add(&num);
    printf("num=%d\n",num);
    Add(&num);
    printf("num=%d\n",num);
    return 0;
}

#include<stdio.h>
int Add(int n)
{
    n = n+1;
    return n;
}
int main()
{
    int num=0;
    num=Add(num);
    printf("%d\n",num);
    num=Add(num);
    printf("%d\n",num);
    num=Add(num);
    printf("%d\n",num);
    return 0;
}

#函数的嵌套调用

int main()
{
    void test()//不能嵌套定义——erro
    {
        printf("hehe\n");
    }
    return 0;
}

#函数调用和链式访问

int main()
{
//    printf("%d\n",strlen("abc"));
//    return 0;
    char arr1[20]="*********";
    char arr2[20]="abc";
    strcpy(arr1,arr2);
    printf("%s\n",arr1);
    printf("%s\n",strcpy(arr1,arr2));//调用函数
}

#printf的返回值

#include<stdio.h>
int main()
{
    printf("%d",printf("%d",printf("%d",43)));
    return 0;
}

good night bobs！never give up！