第五天 指针和函参的二三事

 为什么一次传了这么多篇？

虽然这些笔记在我的本地文档里躺了许多天，也懒得勘误和上传，奈何老师要查 。。。。。

部分程序写完了可能没有编译，这是真的。

#if 1

	指针

//	指针是变量的一种，32位系统占四个字节
	&是取地址的运算符，
	*在定义时表示指针变量，使用的时候表示取值

int a;
int *p =&a;


int *p;  // 野指针,不能用
*p = 3; 

int a = 1;
int *p = NULL; // 空指针，初始化时赋值给他地址
p = &a

*********************************

// 引用实现
Swap1(int &x, int &y)
{
    int temp;
    temp = x;
    x = y;
    y = temp;
}
// 调用
int x = 5;
int y = 6;
Swap1(x, y);

// 指针实现
Swap1(int *x, int *y)
{
    int temp;
    temp = *x;
    *x = *y;
    *y = temp; 
}

// 调用
int x = 5;
int y = 6;
Swap1(&x, &y);

********************************
1）一般实现（需临时变量）
2）利用异或操作实现（不需临时变量）
3）利用加减操作实现（不需临时变量）


#endif




swap(int x,int y)  // 函数调用完以后 x,y,temp被释放
{
	int temp;
	temp=x;
	x=y;
	y=temp;
}


用指针写一个函数 Mystrcpy  



malloc（在堆上申请空间）  默认返回是空类型  这时候需要强制转换
用完 malloc 用完要释放   free


char *src = (char *)malloc(sizeof(char) * 20); // 声明一个指针变量src保存地址（保存在栈上） 

使用 malloc 函数以该地址起始在堆上开辟一个空间，大小为malloc参数 sizeof(char) * 20 


/*程序   1、使用指针实现 strcpy的功能
		 2、使用malloc函数实现字符串打印
		 3、使用指针逆序一个字符串
*/



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

int main()
{
	int length;
	char *tmp;
	char *str = (char *)malloc(sizeof(char) * 20); 
	// 在堆上申请一个内存空间，空间首地址声明为 *str 存于栈中


	if (NULL == str)
	{
		perror("malloc failure");
	}

	printf("请输入一个字符串: \n");
	scanf("%s",str);

	length = strlen(str);

	for (tmp = str + length - 1; tmp >= str; tmp--)
	{
		printf("%c",*tmp);
	}
	

	printf("\n");
	free(str);

	return 0;
}


//使用函数代替逆序的代码段


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

char *reserver(char *s)
{
	int i;
	char *tmp;
	char *ptr = (char *)malloc(sizeof(char) * 20)
	if (NULL == str)  //判断是否申请到了内存
	{
		perror("malloc failure");
	}

	int length = strlen(s)  //strlen 根据地址来找字符串
}

int main()
{
}

**********************************************************


	p之向数组中一个元素 ，p+1 指向下一个元素

	p+i 和 a+i 都是第i各元素的地址


	*  &  a[] 的混合运算

	数组  a+1   地址位加一个元素宽度 二维是加了1行的宽度 a[1][0]
	  	  &a+1	地址位加一个数组宽度 地址位加一个数组宽度 0x........
	  	  a[0]+1  地址位加一个元素宽度 地址位加一个元素宽度 a[0][1]
	  	  *(a+1) == a[i]             *a+1 
	  
	  二维数组 ，中括号取一半 ，a[i][j]中，a[i]表示地址


	  字符数组的定义

	 	char str[] ="hello world!";  存放在栈里，是变量。

	 	char *str ="FAQ";  存放在代码段，而且是常量，只能读不能修改


	 指针数组的打印：
	 char *string[]={ "helloworld","Fing" }；

 	#include <stdio.h>

	int main()
	{
		char *str[] = { "helloworld","Fing" };

		printf("%s\n",*str);
		printf("%s\n", *(str+1));

		return 0;
	}



 	字符串数组的排序


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

void sortBuff(char **buff, int len)
{
	char *temp;    //零时交换变量

	int i, j;

	/*选择排序法*/
	for (i = 0; i < len; ++i) 
	{

		for (j = i + 1; j < len; ++j) 
		{

			if (strcmp(buff[i], buff[j]) > 0) 
			{ //应用string.h  
												//    int strcmp(    
				temp = buff[i];                    //        const char *string1,
												   //        const char *string2 
				buff[i] = buff[j];                //    );
												  //string1 > string2 返回值大于0 ， == 为等于0， < 为小于0
				buff[j] = temp;
			}
		}
	}
}



void printArray(char **buff, int len)
{
	int i;

	for (i = 0; i < len; ++i)
	{
		printf("%s\n", buff[i]);
	}
}


int main()
{
		char *buff[] = { "helloworld", "apple", "114dd","FAQ", "Fing", "RUN" };

		printf("排序前\n");

		printArray(buff, sizeof(buff) / sizeof(buff[0]));

		printf("排序后\n");

		sortBuff(buff, sizeof(buff) / sizeof(buff[0]));

		printArray(buff, sizeof(buff) / sizeof(buff[0]));

		system("pause");
}



宏函数  （优点 节省空间  
		  缺点 增加了编译时间 没有入参判断，不安全）

#include <stdio.h>
#define S(a) a*a
int main()
{
	int k = 2, b = 1;
	S(k + b);  // == S(2+1) == 2+1*2+1预处理时不处理括号展开
	printf("%d\n",S(k+b));
}

输出结果是5 。


*******************************

指针函数

类型说明符（*指针变量名）();

int (*pf)(); 表示pf是一个指向函数入口的指针变量，该函数返回值是整型


函数指针****************
#include <stdio.h>

typedef unsigned char uchar; //定义一个新的数据类型
typedef int(*FUNC)(int, int);

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

int main()
{

	int(*p)(int, int);

		p = add;

	printf("%d\n", p(3, 5));
	return 0;
}

指针函数********************
返回值是指针



int*(*(*fp)(int))[10]  ; 

//fp 是一个指针 ，指向一个函数 函数有一个int类型的形参 函数的返回值是一个指针
// 指向一个有10各元素的数组，每个元素的类型是 int* 类型

int *(*(*array[5])())() ;  ?????????????




.......................函数指针 指针函数 数组指针 指针数组  .........................



☆ 使用函数指针实现正反两个方向的冒泡排序



☆ 指针数组 & 二维指针

&a  指向二维数组的指针 &a + 1 

a   指向第一行地址  a+1