Day 13 函数指针，指针的数组，qsort排序，二分排序，数字转字符，字符转数字

最新推荐文章于 2023-11-15 11:18:49 发布

nihap123456

最新推荐文章于 2023-11-15 11:18:49 发布

阅读量132

点赞数

本文链接：https://blog.csdn.net/nihap123456/article/details/98253589

版权

1.数组的指针 int （p）[10] 指针的变量为p 数据类型为int（ ）[10];
//此为一个二维数组第一行的指针，此二维数组有十列。
//昨天第二小点出错了，括号里面是有 *的，记得加过但是，，，

2.相同的字符串常量在内存中只存一次。
3.函数的函数名是函数的入口地址。
4.指针的数组： char *pstr[3]; sizeof(pstr) = 12; //此大小为12个字节，数组中存了三个指针，一个指针四个字节共12个字节。
5.int (*a)[10]; //数组的指针；
6.函数指针；

int add(int a, int b)
{
	int ret;
	ret = a + b;
	return ret;
}

int sub(int a, int b)
{
	return a - b;
}

int main(void)
{
	//int add(int a, int b);
	int (*p)(int, int);

	p = add;
	p = sub;

	printf("%d\n", p(10, 20));

//	printf("%p\n", add);

	return 0;
}

函数指针：

int fn(int n)
{
	return n;
}

void sort(int *p, int len, int (*pfn)(int))
{
	int i, j;
	for(i = 0;i < len - 1;++i)
	{
		for(j = i + 1;j < len;++j)
		{
			if(pfn(p[i]) > pfn(p[j]))
			{
				int t;
				t  = p[i];
				p[i] = p[j];
				p[j] = t;
			}
		}
	}
}

int main(void)
{
	int i;
	int a[] = {1,-2,3,-4,5,-6,7,-8,9,0};
	sort(a, sizeof(a) / sizeof(a[0]), fn);

	for(i = 0;i < sizeof(a) / sizeof(a[0]);++i)
	{
		printf("%d\n", a[i]);
	}
	return 0;
}

（1）打印1 ~ 100；
（2）使用函数回调的方法打印 1 ~ 100内可以被三整除的数。
（3）使用函数回调的方法打印 1 ~ 100内的素数。
（4）使用函数回调的方法打印 1 ~ 100内的回文数。

int div3(int n)
{
	return n % 3 == 0;
}

int isPrimerNumber(int n)
{
	int i;
	for(i = 2;i < n;++i)
	{
		if(n % i == 0)
		{
			return 0;
		}
	}
	return 1;
}

int textBack(int n)
{
	int k = n;
	int m = 0;
	while(n)
	{
		m = m * 10 + n % 10;
		n /= 10;
	}
	return m == k;
}

void printInt(int n, int (*pfn)(int))
{
	int i;
	for(i = 1;i <= n;++i)
	{
		if(pfn(i))
		{
			printf("%d\n", i);
		}
	}
}

int main(void)
{
	printInt(100, textBack);
	return 0;
}

/*void qsort(void *base（要排序的数组）, size_t nmemb（有多少个元素）, size_t size（每个元素的大小）,
int(*compar)(const void *, const void ) （自己定义的比较函数） );/

int doubleCmp(const void *d1,const void *d2)
{
	double *p1 = (double *)d1;
	double *p2 = (double *)d2;

	return *p1 == *p2 ? 0 : *p1 < *p2 ? -1 : 1;
}

int main(void)
{
	double a[] = {1,2,3,4,5,6,7,8,9,0};

	qsort(a, sizeof(a) / sizeof(a[0]), sizeof(a[0]), doubleCmp);
	//此处已经将 double数组比较排序完成了。
	
	int i;
	for(i = 0;i < sizeof(a) / sizeof(a[0]);++i)
	{
		printf("%f\n", a[i]);
	}

	return 0;
}

执行到0x10002000地址时去执行函数
分析：函数的地址是随机的，但如果要自己定义地址，则使用下面方法。
函数的函数名是函数的入口地址。

void fn(void)
{

}

int main(void)
{
	void (*pfn)(void);  //此处为上面函数的指针。
	//void (*)(void)
	pfn = (void (*)(void))0x10002000;  //此处数据类型匹配。

	pfn();

	return 0;
}

指针的数组，注意函数传参时形参的写法。

void printStrings(char *p[], int len)
{
	int i;
	for(i = 0;i < len;++i)
	{
		puts(p[0]);
	}
}


int main(void)
{
	char *pstr[3];

	pstr[0] = "Hello";
	pstr[1] = "World!";
	pstr[2] = "C language";

	printStrings(pstr, sizeof(pstr) / sizeof(pstr[0]));


	return 0;
}

	int main(int argc, char **argv) //int main(int argc, char *argv[])
{
	int i;
	for(i = 0;i < argc;++i)
	{
		puts(argv[i]);
	}
	
	if(strcmp(argv[1] , "-l") == 0)
	{

	}
	return 0;
   }

指针数组的打印，排序，逆序

void printStrings(char *p[], int len)
{
	int i;
	for(i = 0;i < len;++i)
	{
		puts(p[i]);
	}
}

void reverseStrings(char **p, int len)
{
	int i;
	for(i = 0;i < len / 2;++i)
	{
		char *t;
		t = p[i];
		p[i] = p[len - i -1];
		p[len - i - 1] = t;
	}
}

void sortStrings(char **p, int len)
{
	int i, j;
	for(i = 0;i < len - 1;++i)
	{
		for(j = i + 1;j < len;++j)
		{
			if(strcmp(p[i], p[j]) > 0)
			{
				char *t = p[i];
				p[i] = p[j];
				p[j] = t;
			}
		}
	}
}


int main(void)
{
	char *pstr[] = {"Hello", "World", "C language"};
	
//	reverseStrings(pstr, sizeof(pstr) / sizeof(pstr[0]));
	sortStrings(pstr, sizeof(pstr) / sizeof(pstr[0]));
	printStrings(pstr, sizeof(pstr) / sizeof(pstr[0]));


	return 0;
}

void getMemory(char **p)
{
	*p = malloc(100);
}

void foo(int *n)
{
	++*n;
}

int main(void)
{
	char *p;
	getMemory(&p);
	strcpy(p, "Hello World");
	puts(p);
//	free(p);
	return 0;
}

qsort排序法快排利用指针进行排序。

void swap(int *p1, int *p2) //交换函数
{
	int t;
	t = *p1;
	*p1 = *p2;
	*p2 = t;

}
void qSort(int *begin, int *end)
{
	if(begin >= end)
	{
	
		return;
	}
	 int t = *begin;
	int *p = begin;
	int *q = end;

	while(begin < end)
	{
	
		while(begin < end && *end >= t)
		{
			--end;
		}
		while(begin < end && *begin <= t)
		{
		
			++begin;
		}
		swap(begin, end);
	}
	swap(p, begin);
	qSort(p, begin - 1);
	qSort(begin + 1,q);

}

int main(void)
{
	//int a[] = {3,1,2,6,5,7,4};
   int a[] = {-1,2,3,4,-5,6,7,-8,9,0,20,17,23,65,45,47,82};
	qSort(a, a + sizeof(a) / sizeof(a[0]) -1);
	int i;
	for(i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
	
		printf("%d\n", a[i]);

	}
	return 0;
}

二分查找法：

int *find(int *begin, int *end, int n)
{
	QSort(begin, end);
	while(begin <= end)
	{
		int *mid = (end - begin) / 2 + begin;
		if(*mid > n)
		{
			end = mid - 1;
		}
		else if(*mid < n)
		{
			begin = mid + 1;
		}
		else
		{
			return mid;
		}
	}
	return NULL;
}


int main(void)
{
	int a[] = {1,2,3,4,5,6,7,8,9,0};
	int n = -7;

	int *ret = find(a, a + sizeof(a) / sizeof(a[0]) - 1, n);
	if(ret == NULL)
	{
		puts("not found!");
	}
	else
	{
		printf("%d\n", *ret);
	}

	return 0;
}

将数字转为字符串 itoa

#include <string.h>
void Strreverse(char *p)
{
	int len = strlen(p)  ;
	int i;
	//while(*p)
	for(i = 0; i < len / 2; ++i)
	{
	
		char t;
		t = *(p + i);
		*(p + i) = *(p+len -i-1);
		*(p+len - i- 1) = t;

	/*	t = p[i];
		p[i] = p[len -i -1];
		p[len -i -1] = t;*/
	}

}


void itoa(int n, char *p, int base)
{

	int m = n;
	char *q = p;
	while(n != 0)
	{
		
		if(n < 0)
		{
			n = 0 -n;
		}
		int k = n % base;
		if(k > 9)
		{
		
			*p = k % base + 'A';
			n = n / base;
			++p;
		}
		else
		{
		*p = n % base + '0';
		 n = n / base;
		 ++p;
		}
	}

	if(m < 0)
	{
	
		*p++ = '-';
	
	}

	*p = '\0';
	Strreverse(q);
}

int main(void)
{

	int n = -12345678;
	char s[100];
	itoa(n,s,10);
	puts(s);
	return 0;


}

将字符串转为数组：atio

#include <string.h>
int atoi(const char *p)
{
	int ret = 0;
	while(*p)
	{

	  ret = ret * 10 + (*p -48);
	  ++p;
	}
	
	return ret;
}
int main(void)
{
	
	char s[] = "1234564678";   
	printf("%d\n", atoi(s));
}