指针

指针深入理解

（一）指针概念：指针就是变量，用来存放地址的变量。
代码如下：

#include<stdio.h>
int main()
{
  int a = 10;//在内存中开辟一片空间
  int *p = &a;//将a的地址存放在变量p中，p就是一个指针变量
  return 0；
  }

（二）指针和指针类型
指针的类型是：type+*的方式
1.指针+-整数

   总结：指针的类型决定了指针向前或者向后走一步有多大（距离）。

2.指针的解引用

   总结：指针的类型决定了，对指针进行解引用有多大的权限（能操作几个字符），比如：char *的指针解引用就只能访问一个字节，而int *的指针解引用能访问四个字节。

3.指针的运算

   总结：允许指针向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

常用函数实现

模拟实现my_strlen参考代码：

//不能创建临时变量计数器
int my_strlen(const char * str)
{
if(*str == '\0')
return 0;
else
return 1+my_strlen(str+1);
}
//指针-指针的方式
int my_strlen(char *s)
{
char *p = s;
while(*p != ‘\0’ )
p++;
return p-s;
}

模拟实现strcpy 参考代码：

char *my_strcpy(char *dest, const char*src)
{
char *ret = dest;
assert(dest != NULL);
assert(src != NULL);
while((*dest++ = *src++))
{
;
}
return ret;
}

模拟实现strcat 参考代码：

char *my_strcat(char *dest, const char*src)
{
char *ret = dest;
assert(dest != NULL);
assert(src != NULL);
while(*dest)
{
dest++;
}
while((*dest++ = *src++))
{
;
}
return ret;
}

模拟实现strstr参考代码：

char *my_strstr(const char* str1, const char* str2 )
{
assert(str1);
assert(str2);
char *cp = (char*)str1;
char *substr = (char *)str2;
char *s1 = NULL;
if(*str2 == '\0')
return NULL;
while(*cp)
{
s1 = cp;
substr = str2;
while(*s1 && *substr && (*s1 == *substr))
{
s1++;
substr++;
}
if(*substr == '\0')
return cp;
cp++;
}
}

模拟实现strcmp 参考代码：

int my_strcmp (const char * src, const char * dst)
{
int ret = 0 ;
while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *d
st)
++src, ++dst;
if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;
return( ret );
}

模拟实现memcpy 参考代码：

void * memcpy ( void * dst, const void * src, size_t count)
{
void * ret = dst;
/*
* copy from lower addresses to higher addresses
*/
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
return(ret);
}

模拟实现memmove 参考代码：

void * memmove ( void * dst, const void * src, size_t count)
{
void * ret = dst;
if (dst <= src || (char *)dst >= ((char *)src + count)) {
/*
* Non-Overlapping Buffers
* copy from lower addresses to higher addresses
*/
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
}
else {
/*
* Overlapping Buffers
* copy from higher addresses to lower addresses
*/
dst = (char *)dst + count - 1;
src = (char *)src + count - 1;
while (count--) {
*(char *)dst = *(char *)src;
dst = (char *)dst - 1;
src = (char *)src - 1;
}
}
return(ret);
}

（三）数组指针

    数组指针，是指针。这个指针是有能力指向一个数组的。

int *p[10];
int (*p)[10];//p先和*结合，说明p是一个指针变量量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。

(四）数组参数 指针参数

   1.数组是一种类型。
   2.所有数组传参降级为指向其内部元素的指针。数组传参就两个：数组名，大小。
   3.数组名代表整个数组的时候只有两种情况：
       sizeof(数组名)，这里的数组名表示整个数组。
       &数组名，这里的数组名表示整个数组
   4.数组只能做右值，不能做左值，做右值代表首元素。

#include <stdio.h>//一级指针传参
void print(int *p, int sz)
{
int i = 0;
for(i=0; i<sz; i++)
{
printf("%d\n", *(p+i));
}
}
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9};
int *p = arr;
int sz = sizeof(arr)/sizeof(arr[0]);
print(p, sz);
return 0;
}

#include<stdio.h>//二级指针传参
void test（int ** ptr）
{
   printf("%num =%d\n",**ptr);
 }
 int main()
 {
      int n = 10;
      int*p = &n;
      int **pp = &p;
      test(pp);
      test(&p);
      return 0;
}