24.08.13

day11

1.函数

	函数是具有特定功能的代码块。
        
        
        
函数的一般形式：
        数据类型  函数名(形参列表)
    {
        代码块；
            
        return ？；     
    }


    int  Add(int x, int y)
    {
        return x + y;
    }


函数的调用：
    函数名(实参列表)；
    
    Add(x, y);


函数的声明：
    int  Add(int x, int y)；
    函数在声明的时候形参变量名可以不同，也可以不写。

练习

1.实现减法函数的封装

int Sub(int x, int y)
{
     return x - y;
}

2.设计一个交换函数

 int  swap(int *x, int *y)
 {
     int temp;
     temp = *x;
     *x = *y
     *y = temp;    
 }



 int a = 10, b = 20;
 printf("a:%d b:%d", a, b);
 swap();
 printf("a:%d b:%d", a, b);
	



int swap(int **x, int **y)
{
    int *temp;
    //printf("x:%p y:%p\n", x, y);
    temp = *x;
    *x = *y;
    *y = temp;
    //printf("x:%p y:%p\n", x, y);

    return 0;
}



int main(int argc, char *argv[])
{
    int a = 10, b = 20;
    int *p = &a, *q = &b;
    printf("p:%p q:%p\n", p, q);
    swap(&p, &q);
    printf("p:%p q:%p\n", p, q);

    return 0;
}

函数的传参

1.复制传递

   复制传递方式是函数间传递数据常用的方式。调用函数将实参传递给被调用函数，被调用函数将创建同类型的形参并用实参初始化。即把实参赋给一个新的变量，把实参复制到新建形参的存储区域中。采用复制传递方式传递数据，即使改变形参的值也不会影响实参的值，一旦被调用函数完成了其任务时，这些形参通常就释放其占用空间 。

2.地址传递方式

	地址传递方式和复制传递方式正好相反，这种方式是将调用函数的参数本身传给被调用函数。因此，被调用函数中对形参的操作，将直接改变实参的值。调用函数将实参的地址传送给被调用函数，被调用函数对该地址的目标操作，相当于对实参本身的操作。按地址传递,实参为变量的地址，而形参为同类型的指针。

1.传一位数组

	传的是一维数组的首地址。
        
int func(int a[5]);

int func(int a[]);

int func(int *p);  


eg：
    int arr_show(int *p, int n)
{

    int i;
    for(i = 0; i < n; i++)
    {   
        printf("%d\t", p[i]);
    }   
    puts("");

    return 0;
}


int main(int argc, char *argv[])
{ 
    int a[5] = {1,2,3,4,5};
    int b[10] = {1,2,3,4,5,6,7,8,9,10};

    arr_show(a, sizeof(a) / sizeof(a[0]));
    arr_show(b,sizeof(b) / sizeof(int) );

    return 0;
} 

练习

1.实现封装整型一维数组的排序函数

srand(time(NULL));  //随机数发生器
int ret = rand() %  20          //产生随机数 用ret变量接收， 并控制范围为 0 ~ 19


    
int arr_init(int *p, int n)
{
    srand(time(NULL));
    int i;
    for(i = 0; i < n; i++)
    {   
        p[i] = rand() % 21; 
    }   
}



int arr_show(int *p, int n)
{

    int i;
    for(i = 0; i < n; i++)
    {   
        printf("%d\t", p[i]);
    }   
    puts("");

    return 0;
}


int arr_sort(int *p, int n)
{
    int i, j;
    for(i = 0; i < n -1; i++)
    {   
        for(j = 0; j < n - i - 1; j++)
        {
            if(p[j] > p[j+1])
            {
                int temp;
                temp = p[j];
                p[j] = p[j + 1]; 
                p[j + 1] = temp;
            }
        }
    }   
}


int main(int argc, char *argv[])
{ 
    int a[5] = {1,2,3,4,5};
    int b[10] = {1,2,3,4,5,6,7,8,9,10};

    arr_init(b, 10);
    arr_show(b, 10);
    arr_sort(b, 10);
    arr_show(b, 10);

    
    //arr_show(b,sizeof(b) / sizeof(int) );

    return 0;
} 
    

2.传二维数组

	传的是行地址。
        
int arr_show(int a[3][4]， int h, int l); 

int arr_show(int a[][4]， int h, int l);  

int arr_show(int (*p)[4]， int h, int l);  



    传一级指针
int  arr_show(int *p, int n);   

3.全局变量传参

在函数里，如果全局变量和局部变量名字相同，会优先使用局部变量
         全局变量和局部变量名字不相同，或没有变量的定义，使用全局变量。
    
    
int a = 10; 

void func1(int a)
{
    a = 20; 
}

void func2()
{
    a = 100;
}

int main(int argc, char *argv[])
{ 
    printf("%d\n", a); 
    func1(1314);
    printf("%d\n", a); 
    func2();
    printf("%d\n", a); 

    return 0;
} 

1.const 关键字

1.修饰变量
    const int a = 10；    //a 变量的值不可以被修改 
    a = 30；  //error
    
    int *p = &a；
    *p = 20；


2.修饰指针
    
    指针常量（指针是一个常量）
    	指针的指向不能被修改，指针指向的内容可以修改
    	 int * const p;
    
    
    
    常量指针（常量的指针）
        指针的指向能被修改，指针指向的内容不可以修改
       
        const int *p;
        int const *p;



    const  int  * const  p；

练习

1.封装一个mystrlen

int MyStrlen(const char *str)
{
    int len = 0;

    while(*str != '\0')
    {
        str++;
        len++;
    }

    return len;
}


int main(int argc, char *argv[])
{
    char str[32] = {0};

    printf(":>");
    gets(str);

    printf("%ld  %d\n", strlen(str), mystrlen(str));

    retur

2.指针函数

	是一个函数。返回为指针的函数。

注意：
    1.不能返回局部变量的地址  
    2.可以返回static 修饰的局部变量的地址    

练习

1.实现mystrcpy

har *mystrcpy(char *dest, const char *src)
{
    char *ret = dest;

    while(*src)
    {
        *dest++ = *src++;
    }
    *dest = '\0';

    return ret;
}



int main(int argc, char *argv[])
{

    char str1[32] = "123456789";
    char str2[32] = "xxxxxx";


    puts(mystrcpy(str1, str2));


    return 0;
}