指针2024.02.03

指针

指针可以比较大小；

根据数组的有序性，可以比较大小.  p>q,输出逻辑结果。

int *p = a;
int *q = a + 2;

对数组的遍历

  void printfArry(int *begin,int *end)
  {
      while(begin <= end)
      {                                                                                           
          printf("%d\n",*begin);
         ++begin;
      }
  }

逆序

 1 #include<stdio.h>
  2 
  3 void swap(int *a,int *b)                  //交换
  4 {
  5     int t;
  6     t = *a;
  7     *a = *b;
  8     *b = t;
  9 }
 10 void reverse(int *begin,int *end)           //逆序
 11 {
 12     while(begin < end)
 13     {
 14         swap(begin,end);
 15         ++begin;
 16         --end;
 17     }
 18 }


 int main(void)                                 //主函数
 28 {
 29     int a[] = {1,2,3,4,5,6,7,8,9};
 30     int len = sizeof(a) / sizeof(*a);
 31     int *bengin = a;
 32     int *end  = a + len - 1;
 33     reverse(a,a + len - 1);
 34     printfArry(a,a + len - 1);

使用递归的方式逆序

 10 void reverse(int *begin,int *end)
 11 {
 18     if(begin >= end)
 19     {
 20         return;
 21     }
 22     else
 23     {
 24         swap(begin,end);
 25         ++begin;
 26         --end;
 27         reverse(begin,end);
 28     }
 29 } 

选择排序

void choiceSort(int *begin,int *end)
 31 {
 32     int *p = begin + 1;
 33     for(;begin <end;++begin)
 34     {
 35         for(p = begin + 1;p <= end;++p)
 36         {
 37             if(*begin > *p)
 38             {
 39                 swap(begin,p);
 40             }
 41         }
 42     }
 43 }

冒泡排序

void bubble(int *begin,int *end)
{ 
	for(;end >= begin;--end)
	{
		int *p = begin;
		for(p = begin;p < end;++p)
		{
			if(*p > *(p + 1))
			{
				swap(p,p + 1);
			}
		}
	}
}

二分法查找

int *binaryFinf(int *begin,int *end,int n)
	
{   
	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 0;
}

用递归的方式
int *binaryFind(int *begin,int *end,int n)
{
	int *mid = (end - begin) / 2 + begin;
	if(begin > end )
	{
		return 0;
	}
	if(*mid > n)
	{
		return binaryFind(begin,mid - 1,n);
	}
	else if(*mid < n)
	{
		return binaryFind(mid + 1,end,n);
	}
	else 
	{
		return mid;
	}
}

快速排序算法

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

字符串与指针

strlen

    int Strlen(const char *s)
111 {
112     int i = 0;
113     while(*s)
114     {
115         ++s;                                                                   
116         ++i;
117     }
118     return i;
119 }
120 int mystrlen(const char *s)
121 {
122     if(*s == '\0')
123     {
124         return 0;
125     }
126     else
127     {
128         return mystrlen(s + 1);
129     }
130 }

strcpy 和 strncpy

    char *Strcpy(char *dest,const char *src)
132 {
133     char *ret = dest;
134     while(*src)
135     {
136         *dest = *src;                                                          
137         ++src;
138         ++dest;
139     }
140     *dest = 0;
141     return ret;
142 }
143 char *Strncpy(char *dest,const char *src,unsigned long n)
144 {
145     char *ret = dest;
146     while(*src && n > 0)
147     {
148         *dest++ = *src++;
149         --n;
150     }
151     *dest = 0;
152     return ret;
153 }

char *p;
p = "Hello World!";

p中只有 “H”的地址

char *p;
p = "Hello World!";
printf("%d\n",strlen(p));

12

有效长度是6

sizeof(s）100

不能修改字符串常量区

第一个  只读   int i = 10；

在指针变量前加const  表明无法通过该指针修改其指向的变量

不能修改*p    

p不能被修改 但是不影响他指向的变量

static 关键字 

全局变量，static修饰的局部变量,  在静态生存期

stctic + 全局变量\函数  限制使用范围仅本身.c文件可以使用

const   是否要加  取决于函数里是否需要通过该指针修改指针指向的内容。

如果不需要修改，加const 修饰

Hello

void *p 万能指针

可以接收任何类型的地址，可以指向任何类型的变量

万能指针不能作为指针进行指针运算，例如 *p = 1.23❌

主要是用来强转            memcpy