指针

char name;

char  *pname;           ##################定义了指向字符变量的指针变量

pname = &name;       ##################这是取同类型数据的变量的地址赋值给指针变量

                                   ###表示：1---将字符变量name的地址赋值给指针变量pname，指向该字符变量

                                   #######：2---取变量name地址：“&”取地址运算符：只能取内存中变量的地址，不能取表达式或常量的地址

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

char stuname;

char name;

char *pname = &name;

char *pstuname = pname; #################这是同类型指针变量相互赋值：

                                        ####：pname和pstuname同时指向字符变量name，他们的值都是该变量的地址

                                       #####：前提是：pname指针已经获得确切地址，否则，不能把该指针变量赋值给另一指针变量

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

char name;

char *pname;

char *pstuname;

pstuname = pname;

char ch = *pstuname;

                                    ###：因为pname存储的地址未确定，也即指针变量没有指向具体的内存单元，没有指向具体的变量

                                   ####：指针变量使用前必须指向具体有效的内存单元

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int num;

int *p;

p = #

*p = 5;

############：通过指针变量访问所指向的变量

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

type name;

type_a  aname;

type *p;

p = &name;

p = &aname;--------------------wrong !!!

##############################：指针变量只能指向相同类型的变量；

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                                                          指针与整数之间：相加减

int Num[4] = {12,13,14,15};

int *p_int;

p_int = Num;                       ####：指针变量指向指向数组的第一个元素：p_int = &Num[0]

p_int++;              ###：指向下一个元素Num[1]             

p_int = p_int+2;   ###:指向Num[3]

################：数组名就是数组中第一个元素地址，是元素的地址，是第一个元素。

#################：指向数组元素的指针变量加一：表示移动数组元素大小的字节数

总结：type类型数组数组Num[]，当指针p指向type类型数组的第一个元素时，p=p+n后，p指向Num[n]，地址改变了n*sizeof(type)大小

         同理：p=p-n，则是向前移动

       总之，向前不能超过数组第一个元素，向后不能超过最后一个元素

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                                                     指针之间：相减不能相加

前提是两个指针指向同一个数组，否则没有意义：

int  Num[5] = {11,12,13,14,15};

int *p_a = &Num[0];

int *p_b = &Num[3];

int i = p_b - p_a;

i = 2;

#################：结论就是：两个指向同一数组的元素的指针变量相减，结果等于两个指向的元素之间的元素个数

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

数组：数组元素都是同一数据类型，不能混合。

int num[7] = {1,2,3,4,5,6,7};    ####：int类型数组，编译器认为num[]只能存放int类型的数据

char sstr[26];   ####：char类型数组

char str[] = {" LOVE"};                              #####：字符数组初始化为字符串，会在最后添加字符串结束标志：“\0”

元素值   ：空格        L         O         V         E          \0

数组元素：str[0]    str[1]    str[2]   str[3]   str[4]      str[5]

内存地址：0xa0    0xa1    0xa2    0xa3    0xa4      0xa5

float dat[10];  ####：float类型数组

数组 = 数组名+数组元素类型+数组元素个数+初始化；

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                                                               引用数组元素

int num[5] = {11,12,13,14,15};

int *p;

p = num; 指向数组------------------------------------------数组指针：用数组名赋值给指针变量

p = num[0];指向数组元素

第一个元素是：num[0]

第一个元素地址是：&num[0]

数组名：num ： 就是数组第一个元素num[0]的地址，是一个地址常量。        数组首地址=数组首元素地址**********数组首元素地址常量****************************************

所以：num和&num[0]指向同一单元

结论：指针可以指向数组（数组名），也可以指向数组元素。

使用数组元素时：num[3]等，必须知道该元素的下标，该元素在数组中的位置

使用数组元素时：指针。

数组：以数组第一个元素的首地址开始的一段内存块。

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

char str[] = "iGLC1314520";

char *pstr;    ######：字符指针可以指向普通变量；可以指向数组

pstr = str;      #####：将字符数组名赋值给字符指针变量；字符数组初始化为字符串和其他初始化有区别：字符串会自动加上“\0”，其他则没有。

                   ######：str和pstr都是指向数组第一个元素，前者地址常量，后者变量          

pstr = &str[3];可以指向数组元素

                                                                     ***********************str值等于&str值*********************************

数组名和&数组名值相等，但是含义不同：前者是数组首元素的地址常量，偏移为数组元素大小；后者是整个数组的首地址，偏移为整个数组大小

int a[10];

&a[0]   类型是int

a         类型是int a[10]

&a      类型是int (*)[10]

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int a[10]

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

a+0                  第0个元素地址

a+1                 第1个元素地址

。。。。。

a+9               最后一个元素地址

'''''''''''''''''''''''''

*(a+0)            第0个元素的内容

*(a+1)            第1个元素内容

。。。。。

*(a+9)            最后一个元素内容

''''''''''''''''''''''''''''

&a+0             int(*)[10]类型的首地址

&a+1            偏移int(*)[10]大小

&a+2

。。。。。

&a+n

'''''''''''''''''''''''''''''''''

我们把数组看成基本数据类型变量：int[10]

                                                     &a：就是变量a的地址，a的作用范围是10个int

                                                     若将&a赋值给指针变量，则必须定义为int(*)[10]类型，

                                                     int (*p)[10];

                                                     p = &a;

             

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////        

                                             指针类型数组

type *数组名[数组元素个数]

int  *num[3];

char *argv[5] = {“china”,"German","iGLC1314520",NULL,NULL}；

argv[0]         argv[1]                argv[2]                    argv[3]     argv[4]

"china"       "German"       "iGLC1314520"              NULL       NULL                                    

char*argv[] = {"gbhgtfbgfd","bhgnhg"," advg"};

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

char *pstr = "egtrhdrtbher";

。。。。。。。。。。。。。

char *pstr;

pstr = "degfvtrshty";

char *str[] = "strjhnrthvceshyuu";

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                                                                        函数中参数：普通参数和指针参数，传递的都是值，前者传递变量的数值，后者传递变量的地址值

函数传递：总是单向的值传递

指针作函数参数：传递变量的地址，传递指针变量的值，函数调用时，将该参数传递给函数内部处理

                            实际上，就是让形参同时指向实参指向的数据单元

所以，同样是值传递和单向传递，普通参数和指针参数不同：

1-----普通参数，传递变量本身的数值，函数调用时，不能同时对这些实参变量值改变

2-----指针参数，以变量、函数等的指针作为参数，传递变量（地址）本身的值，通过地址直接改变主调函数变量的值

结论：想在被调函数中改变实参值，就用指针变量