C语言、指针（一）

指针（一）

• 　　“带*类型” 的特征探测：宽度
• 　　“带*类型” 的特征探测：声明
• 　　“带*类型” 的特征探测：赋值
• 　　“带*类型” 的特征探测：++ --
• 　　“带*类型” 的特征探测：加上/减去 一个整数
• 　　“带*类型” 的特征探测：求差值
• 　　“带*类型” 的特征探测：比较

　　对于一个变量来说，最重要的一个特征就是数据的宽度，如何探测某个类型的变量的宽度？

　　答：我们可以用sizeof，当然最好我们是看反汇编看他到底分配几个字节。

1、“带*类型” 的如何声明？

　　如何声明char/short/int类型的变量呢？

 char x;                

 short y;                

 int z;                

 float f;                

 double d;                

 struct Student
 {
     int level;
     char name[];
 };                

 Student st;                

　　声明带有*类型的变量

　　

　

　　总结： 

　　1、带有*的变量类型的标准写法：变量类型* 变量名

　　2、任何类型都可以带* 加上*以后是新的类型

　　3、*可以是任意多个

2、“带*类型” 的特征探测：赋值

char、short、int 类型变量的赋值：

　　

 #include "stdafx.h"

 struct point
 {
     int a;
     char arr[];
 };

 void function()
 {
     char a;
     short b;
     int c;

     a = ;
     b = ;
     c = ;

 }

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

     return ;
 }

　　反汇编代码如下：

　　

　　从 mov byte ptr ds:[ebp-4],1

　　mov word ptr ds:[ebp-8],2。不难看出char占1个字节，short占2个字节，int占四个字节，但是从反汇编代码中可以看出，虽然char占1个字节，short占2个字节，但是编译器为它分配内存的时候，依旧是分配了4个字节

带*类型的变量的赋值：

　　

 #include "stdafx.h"

 struct point
 {
     int a;
     char arr[];
 };

 void function()
 {
     char* a;
     short* b;
     int* c;

     a = (char*);
     b = (short*);
     c = (int*);

 }

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

     return ;
 }

　　

　　从这段反汇编代码看出，这与普通变量的赋值毫无差别，说明仅仅从汇编角度，编译器是不识别你什么指针不指针的。

　　我们再来看看带两颗*的情况

 #include "stdafx.h"

 struct point
 {
     int a;
     char arr[];
 };

 void function()
 {
     char** a;
     short** b;
     int** c;

     a = (char**);
     b = (short**);
     c = (int**);

 }

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

     return ;
 }

　　再观察带两个*的变量的反汇编

　　可以看出与带一个*的反汇编代码一毛一样

　　我们再来看看多颗*的情况，这回我下了一剂猛药，直接来十颗*！

 #include "stdafx.h"

 struct point
 {
     int a;
     char arr[];
 };

 void function()
 {
     char********* a;
     short********* b;
     int********* c;

     a = (char*********);
     b = (short*********);
     c = (int*********);

 }

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

     return ;
 }

　　观察反汇编代码如下！

　　

　　看到这，你可能会怀疑我是不是压根没看反汇编代码，而是直接把上面的复制过来了 ，如果不是复制过来的，那为毛他们反汇编代码一毛一样，一个符号都没有改呢？其实在反汇编里头，无论你是带有几颗*，一律只占（4）dword字节

再探数据的宽度：

　　

　　赋值+探测宽度我一并做过了，这个就不写了

　　总结：

　　1、带*类型的变量赋值时只能使用“完整写法”.

　　2、带*类型的变量宽度永远是4字节、无论类型是什么，无论有几个*.

3、“带*类型” 的特征探测：++ --

　　由于加法与减法是一样的，我这里只做加法的演示！！！

char、short、int类型：

　　

 #include "stdafx.h"

 struct point
 {
     int a;
     char arr[];
 };

 void function()
 {
     char a ;
     short b ;
     int c ;            

     a = ;
     b = ;
     c = ;            

     a++;
     b++;
     c++;            

     printf("%d %d %d",a,b,c);            

 }

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

     return ;
 }

　　打印的结果如下：

·　　

带*类型

　　算了，为了合理演示，这里不适合从1颗*到多颗*，得反过来，得从多颗*到1颗*演示才好

　　1、带多颗*的类型

 #include "stdafx.h"

 struct point
 {
     int a;
     char arr[];
 };

 void function()
 {
     char********** a ;
     short********** b ;
     int********** c ;        

     a = (char**********);
     b = (short**********);
     c = (int**********);        

     a++;
     b++;
     c++;        

     printf("%d\n %d\n %d\n",a,b,c);
 }

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

     return ;
 }

　　打印结果如下：

　　

　　2、带两颗*的类型

 #include "stdafx.h"

 struct point
 {
     int a;
     char arr[];
 };

 void function()
 {
     char** a ;
     short** b ;
     int** c ;        

     a = (char**);
     b = (short**);
     c = (int**);        

     a++;
     b++;
     c++;        

     printf("%d\n%d\n%d\n",a,b,c);
 }

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

     return ;
 }

　　打印结果如下：

　　

　　3、带一颗*的类型

　　来了来了，重点在这！！！

 #include "stdafx.h"

 struct point
 {
     int a;
     char arr[];
 };

 void function()
 {
     char* a ;
     short* b ;
     int* c ;        

     a = (char*);
     b = (short*);
     c = (int*);        

     a++;
     b++;
     c++;        

     printf("%d\n%d\n%d\n",a,b,c);
 }

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

     return ;
 }

　　打印结果如下：

　　

　　注意看了，结果跟上面不一样了哦！

　　做加法或者减法运算时，带*类型会在自身具体多少颗*的基础上，会砍掉一颗*做加法，减法

　　还记得前面说的类型宽度吗？任何带*类型，它的宽度都是4字节，两颗*以上的，砍掉一颗*，他还是带*类型，只有是带一颗*的类型，他做加减的时候，砍掉一颗*就跟普通变量是一样的了

　　总结：

　　1、不带*类型的变量，++或者-- 都是假1 或者减1

　　2、带*类型的变量，可是进行++ 或者 --的操作

　　3、带*类型的变量，++ 或者 -- 新增(减少)的数量是去掉一个*后变量的宽度

4、“带*类型” 的特征探测：加上/减去 一个整数

　　带一颗*的类型

 #include "stdafx.h"

 struct point
 {
     int a;
     char arr[];
 };

 void functionAdd()
 {
     char* a ;
     short* b ;
     int* c ;        

     a = (char*);
     b = (short*);
     c = (int*);        

     a = a + ;
     b = b + ;
     c = c + ;        

     printf("%d %d %d\n",a,b,c);
 }
 void functionSub()
 {
     char* a ;
     short* b ;
     int* c ;        

     a = (char*);
     b = (short*);
     c = (int*);    

     a = a - ;
     b = b - ;
     c = c - ;
     printf("%d %d %d\n",a,b,c);
 }

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

     return ;
 }

　　打印结果如下：

 　　

　　带两颗*的呢？

 #include "stdafx.h"

 void functionAdd()
 {
     char** a ;
     short** b ;
     int** c ;        

     a = (char**);
     b = (short**);
     c = (int**);        

     a = a + ;
     b = b + ;
     c = c + ;        

     printf("%d %d %d\n",a,b,c);
 }
 void functionSub()
 {
     char** a ;
     short** b ;
     int** c ;        

     a = (char**);
     b = (short**);
     c = (int**);    

     a = a - ;
     b = b - ;
     c = c - ;
     printf("%d %d %d\n",a,b,c);
 }

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

     return ;
 }

　　打印结果如下：

　　

　　带很多*的情况呢？

 #include "stdafx.h"

 void functionAdd()
 {
     char********** a ;
     short********** b ;
     int********** c ;        

     a = (char**********);
     b = (short**********);
     c = (int**********);        

     a = a + ;
     b = b + ;
     c = c + ;        

     printf("%d %d %d\n",a,b,c);
 }
 void functionSub()
 {
     char********** a ;
     short********** b ;
     int********** c ;        

     a = (char**********);
     b = (short**********);
     c = (int**********);    

     a = a - ;
     b = b - ;
     c = c - ;
     printf("%d %d %d\n",a,b,c);
 }

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

     return ;
 }

　　打印结果如下：

　　

　　总结：

　　1、带*类型的变量可以加、减一个整数，但不能乘或者除.

　　2、带*类型变量与其他整数相加或者相减时：

　　带*类型变量 + N = 带*类型变量 + N*(去掉一个*后类型的宽度)

　　带*类型变量 - N = 带*类型变量 - N*(去掉一个*后类型的宽度)

5、“带*类型” 的特征探测：求差值

　　有点累了，就都写一块了，如果读者有心，建议后面的步骤，都如同上面的步骤一样，从char、short、int、__int64、结构体带*变量都试试，从一颗*到多颗*，都试试

　　注意：只允许两个带星（*）类型做减法，不允许两个都带星（*）的类型相加，但是带星类型对整数类型可以做加减。

　　希望各位看我博客的各位，不要记这些啊，这些都不用记得，你如果要说这么多内容不记住怎么懂呢？其实，你只需要按照我这个顺序，从char、short、int、__int64、数组，结构体定义变量，求宽度，做加减，作比较

　　再到char、short、int、__int64、数组，结构体带一颗星的声明一个变量，求宽度、做加减，作比较

　　再到char、short、int、__int64、数组，结构体带多颗星的声明一个变量，求宽度，做加减作比较，就自然懂了

　　

 #include "stdafx.h"

 void CharOnePoint()
 {
     char* a ;
     char* b ;    

     a = (char*);
     b = (char*);    

     int x = a - b;    

     printf("%d\n",x);
 }

 void ShortOnePoint()
 {
     short* a ;
     short* b ;    

     a = (short*);
     b = (short*);    

     int x = a - b;    

     printf("%d\n",x);
 }

 void IntOnePoint()
 {
     int* a ;
     int* b ;    

     a = (int*);
     b = (int*);    

     int x = a - b;    

     printf("%d\n",x);
 }

 void CharMorePoint()
 {
     char********** a ;
     char********** b ;    

     a = (char**********);
     b = (char**********);    

     int x = a - b;    

     printf("%d\n",x);
 }

 void ShortMorePoint()
 {
     short********** a ;
     short********** b ;    

     a = (short**********);
     b = (short**********);    

     int x = a - b;    

     printf("%d\n",x);
 }

 void IntMorePoint()
 {
     int********** a ;
     int********** b ;    

     a = (int**********);
     b = (int**********);    

     int x = a - b;    

     printf("%d\n",x);
 }

 int main(int argc, char* argv[])
 {
     CharOnePoint();
     ShortOnePoint();
     IntOnePoint();
     printf("\n\n\n");
     CharMorePoint();
     ShortMorePoint();
     IntMorePoint();

     return ;
 }

 　　

　　

　　总结：

　　1、两个类型相同的带*类型的变量可以进行减法操作.

　　2、想减的结果要除以去掉一个*的数据的宽度.

6、“带*类型” 的特征探测：比较

 #include "stdafx.h"

 void function()
 {
     char**** a ;
     char**** b ;            

     a = (char****);
     b = (char****);                

     if(a>b)
     {
         printf("1\n");
     }
     else
     {
         printf("2\n");
     }            

 }

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

     return ;
 }

　　

　　总结：

　　带*的变量，如果类型相同，可以做大小的比较。