现在的位置: 首页 > 综合 > 正文

指针 （整理版）

2018年04月20日 ⁄ 综合 ⁄ 共 6133字 ⁄ 字号 小 中 大 ⁄ 评论关闭

指针是C/C++编程中的重要概念之一，也是最容易产生困惑并导致程序出错的问题之一。利用指针编程可以表示各种数据结构，通过指针可使用主调函数和被调函数之间共享变量或数据结构，便于实现双向数据通讯；指针能够灵活的操作内存，合理的操作内存能够使程序更高效。

1.指针的概念 

本质上讲指针也是一种变量，普通的变量包含的是实际的数据，而指针变量包含的是内存中的一块地址，这块地址指向某个变量或者函数，指针就是地址。指针是一个指示器，它告诉程序在内存的哪块区域可以找到数据。

2.指针的内容 

指针的内容包含4部分：指针的类型，指针所指向的类型，指针的值，指针本身所占有的内存区。在初学指针时，指针的类型和指针所指向的类型是极容易搞混淆的，弄清楚这些概念，有助于我们正确的使用指针。

3.指针的类型和指针所指向的类型 

从语法上讲，指针的类型是指把指针声明语句中的指针名字去掉所剩下的部分。 

指针指向的是一块内存区域，指针所指向的类型取决于这块内存在编译时是什么类型，比如一个int*类型指针所指向的类型是int。 

下面我来就一些例子来对这两个概念进行说明。

  1. int p;//这仅仅是一个普通的变量
  2.  
  3. int* p;//int*也表示一种数据类型：int指针类型。所以p的类型为：int*类型，p所指向的类型为int型

到这里，稍微暂停一下。教大家一种如何看待指针类型和指针所指向的类型的方法。(我自己的理解) 

就上面这个int*p例子来说，它可以写成int* p，也可以写成int
*p。第一种的理解偏向于地址，就是p是一个地址变量，p表示一个十六进制地址；第二种的写法偏向于值，*p是一个整型变量，它能够表示一个整型值。 

这两种写法都正确，只是理解上不同，但是我认为，在理解指针类型和指针所指向的类型这两个概念时，完全可以把它们两个结合起来。 

想想我们使用指针的步骤：声明指针，为指针赋值，然后使用指针所指向的值。 
我们都知道指针是一种复合数据类型，它必须和基本的类型结合才能构成指针类型。 

那么int*就是一种复合的数据类型——整型指针类型。 

这样就好解释第一种写法了，在声明时，int* p，直接声明p变量为整型指针类型，这是第一步。 

第二步就是为指针赋值了，p是指针类型，它存放的是地址，这里假设我这样为它赋值：p = &普通变量;（比如int a = 5;p=&a;）。 

第三步使用指针，在C++ Primer中详细的解释了*是解除引用的运算符（我的理解是地址解析运算符），如果p是地址，那么*p就是实际的值（比如上面对应的*p = 5）。对于初学者来说，在理解它的含义时，完全可以跨过这一步，上面说了在声明指针时int*
p和int *p这两种写法都可以，在声明时我偏向第一种理解，在使用时我偏向第二种理解：毕竟我们使用的是值，而*p就是这个值。 

我的结论：对于int* p和int *p的理解（也是对于指针类型和指针所指向的类型的理解），一个指针包含两部分，地址和值，指针声明时声明的是一个地址变量（指针就是地址），在使用时使用的是指针所指向的值。或者说指针包含两个类型：指针类型和指针所指向的类型，声明时是声明指针类型，使用时是使用指针所指向的类型。

  1. int p[3];//p先和[]结合，说明p是一个数组，再和int结合，所以p是一个int型数组
  2.  
  3. int* p[3];//优先级[]比*高，p是数组，再加上int*，可以称它为指针数组，数组的每一个元素的值都为指针（地址）
  4.  
  5. int (*p)[3];//*p可以看作是普通变量，就回到第三种情况（int
    p[3]），但是这里p是指针变量，它指向的是一个包含3个整型数值的数组。可以称它为数组指针，数组中每一个元素的值为普通整型值。
  6.  
  7. int** p;//int*代表指针类型，*是指针类型，所以p是指向int型指针的指针，p指向的类型是int*类型（int型指针）
  8.  
  9. int p(int);//这很明显是一个返回类型为int，并且带一个int型参数的函数
  10.  
  11. int (*p)(int);//p是函数指针，指向的是返回值为int并且带一个int参数的函数。这个声明包含两部分：函数变量+函数地址变量（姑且把函数也看做是变量）
  12.  
  13. int* (*p(int))[3];//这个有点复杂，它仍然是一个函数指针。从*p(int)看，它是函数指针，带一个int参数；然后看[]，说明函数返回值为数组，然后返回类型为int*。所以p是一个指向返回值为int*型指针数组，并且带一个int型参数的函数的指针

在平常使用中，我们只需要理解前面几个就可以了，太复杂的指针基本用不到，可读性也不好。

下面是一些指针的简单例子。

Demo1 &和*操作符

  1. #include
  2. int main()
  3. {
  4.     using namespace std;
  5.     int updates = 6;
  6.     int *p_updates;
  7.     p_updates = &updates;
  8.  
  9.     cout<<"Values: updates = "<<updates;
  10.     cout<<", *p_updates = "<<*p_updates<<endl;
  11.  
  12.     cout<<"Address: &updates = "<<&updates;
  13.     cout<<",p_updates = "<<p_updates<<endl;
  14.  
  15.     *p_updates = *p_updates + 1;
  16.     cout<<"Now updates = "<<updates<<endl;
  17. }

Demo2

  1. #include
  2. int main()
  3. {
  4.     using namespace std;
  5.     int higgens = 5;
  6.     int* pt = &higgens;//是对pt进行赋值，而不是*pt。等价于int*
    pt; pt = &higgens;
  7.  
  8.     cout<<"Value of higgens = "<<higgens<<endl;
  9.     cout<<"Addnress of higgens = "<<&higgens<<endl;
  10.     cout<<"Value of *pt = "<<*pt<<endl;
  11.     cout<<"Value of pt = "<<pt<<endl;
  12.  
  13.     return 0;
  14. }

Demo3  new和delete操作符

  1. #include
  2. int main()
  3. {
  4.     using namespace std;
  5.     int* pt = new int;
  6.     *pt = 1001;
  7.     cout<<"int value = "<<*pt<<",and
    location = "    <<pt<<endl;
  8.     double* pd = new double;
  9.     *pd = 5.234;
  10.     cout<<"double value = "<<*pd<<",and
    location = "    <<pd<<endl;
  11.     delete pt;
  12.     delete pd;
  13.     return 0;
  14. }

Demo4 动态数组

  1. #include
  2. int main()
  3. {
  4.     using namespace std;
  5.     double* p3 =  new double[3];
  6.     p3[0] = 0.2;
  7.     p3[1] = 0.5;
  8.     p3[2] = 0.8;
  9.  
  10.     cout<<sizeof(p3)<<endl;
  11.     cout<<"p3[1] is "<<p3[1]<<".\n";
  12.     p3 = p3 + 1;//增加一位地址，这里的一位的单位标准是按照数组的一个元素占内存的字节数。
  13.     cout<<"Now p3[0] is "<<p3[0]<<"
    and p3[1] is "    <<p3[1]<<".\n";
  14.     cout<<sizeof(p3)<<endl;
  15.     p3 = p3 -1;
  16.     delete[] p3;
  17.     return 0;
  18. }

Demo 5 数组和指针

  1. #include
  2. int main()
  3. {
  4.     using namespace std;
  5.     double wages[3] = {10000.0,20000.0,30000.0};
  6.     short stacks[3] = {3,2,1};
  7.     //两种方式去获取数组的地址——数组名或对数组首元素进行求址运算
  8.     double* pw = wages;
  9.     short* ps = &stacks[0];
  10.  
  11.     cout<<"pw = "<<pw<<",*pw
    = "    <<*pw<<endl;//打印出数组第一个元素的值和地址
  12.     pw = pw + 1;
  13.     cout<<"add 1 to the pw pointer:\n";
  14.     cout<<"pw = "<<pw<<",*pw
    = "    <<*pw<<"\n\n";
  15.  
  16.     cout<<"ps = "<<ps<<",*ps
    = "    <<*ps<<endl;//打印出数组第一个元素的值和地址
  17.     ps = ps + 1;
  18.     cout<<"add 1 to the ps pointer:\n";
  19.     cout<<"pw = "<<ps<<",*ps
    = "    <<*ps<<"\n\n";    
  20.  
  21.     //stacks[1] 等同于 *(stacks + 1)
  22.     cout<<"access two elements with array notation\n";
  23.     cout<<" stacks[0] = "<<stacks[0]<<",
    stack[1] = "    <<stacks[1]<<endl;
  24.     cout<<"access two elements with pointer notation\n";
  25.     cout<<"*stacks = "<<*stacks<<",*(stacks
    + 1) = "    <<*(stacks + 1)<<endl;
  26.  
  27.     cout<<sizeof(wages)<<"
    = size of wages array\n"    ;    //24字节
  28.     cout<<sizeof(pw)<<"
    = size of pw pointer\n"    ;            //4字节
  29.  
  30.     return 0;
  31. }

Demo6 字符串和地址

  1. #include
  2. int main()
  3. {
  4.     using namespace std;
  5.     char flower[10] = "rose";
  6.     //字符串发送地址给cout对象。
  7.     //在cout和多数C++表达式中，char数组名、指向char的指针以及用引号括起来的字符串常量都被解释为字符串第一个字符的地址
  8.     cout<<flower<<"s are red.\n";
  9.     return 0;
  10. }

Demo7 字符串和地址

  1. #include
  2. #include
  3. int main()
  4. {
  5.     using namespace std;
  6.     char animal[20] = "bear";
  7.     const char* bird = "wren";//bird存放字符串的地址
  8.     char* ps;
  9.  
  10.     cout<<animal<<" and ";
  11.     cout<<bird<<"\n";
  12.  
  13.     cout<<"Enter a kind of animal:";
  14.     cin>>animal;
  15.     //cin>>ps;//没有为ps分配内存空间，这样做是错误的
  16.  
  17.     ps = animal;//ps和animal指向同一个string和内存单元
  18.     cout<<ps<<"s!\n";
  19.     cout<<"Before using strcpy():\n";
  20.     cout<<animal<<" at "<<(int*)animal<<endl;//计算animal的地址,如果是char*类型，则打印出字符串
  21.     cout<<ps<<"
    at "    <<(int*)ps<<endl;
  22.  
  23.     ps = new char[strlen(animal)
    + 1];//分配新的内存空间
  24.     strcpy(ps,animal);//数组拷贝，如果这里把animal赋给ps，这样将改变ps的地址，我们将无法操作新分配的内存
  25.     cout<<"After using strcpy():\n";
  26.  
  27.     //虽然animal和ps指向的是同一个string，但是它们的内存地址是不同的
  28.     cout<<animal<<" at "<<(int*)animal<<endl;
  29.     cout<<ps<<"
    at "    <<(int*)ps<<endl;
  30.     delete[] ps;
  31.  
  32.     return 0;
  33. }

Demo8 动态结构 ->指向操作符

  1. #include
  2. struct inflatable
  3. {
  4.     char name[20];
  5.     float volume;
  6.     double price;
  7. };
  8. int main()
  9. {
  10.     using namespace std;
  11.     inflatable* ps = new inflatable;//在运行时分配内存
  12.     cout<<"Enter name of inflatable item:";
  13.     cin.get(ps->name,
    20);
  14.     cout<<"Enter volume in cubic feet:";
  15.     cin>>(*ps).volume;
  16.     cout<<"Enter price:$";
  17.     cin>>ps->price;
  18.     cout<<"Name:"<<(*ps).name<<endl;
  19.     cout<<"Volume:"<<ps->volume<<"
    cubic feet\n"    ;
  20.     cout<<"Price:$"<<ps->price<<endl;
  21.     delete ps;
  22.     return 0;
  23. }

4.指针的值（或称指针所指向的内存区）

指针的值或者叫指针所指向的内存区或地址，是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。 指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。

指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在上例中，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的。

以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指的类型是什么？该指针指向了哪里？

5.指针本身所占有的内存区

指针本身所占有的内存区是指针本身占内存的大小，这个你只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里，指针本身占据了4个字节的长度。

指针本身占据的内存这个概念在判断一个指针表达式是否是左值时很有用。

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞