理解一般指针和指向指针的指针

在说指向指针的指针之前,不得不说指向变量的指针。先看如下示例:

1. 指向整型指针

先看如下示例:

1 #include <iostream>
using namespace std;

int main()
{
int a = 5;
int * p = &a;
cout << "a = " << a << endl
<< "&a = " << &a << endl
<< "*p = " << *p << endl
<< "p = " << p << endl
<< "&p = " << &p << endl;

return 0;
}

运行结果如下:

我们先看下内存分配图:

由上图可以清楚的知道,输出整形变量a的值是5,指针变量p的值是001BFD18,而*号的作用是取值,*p即取地址001BFD18中存放的值,即5。

2. 指向字符型指针

先看如下示例:

1 #include <iostream>
using namespace std;

int main()
{
    char a[] = "hello";
    char *p = a;

    cout << "p = " << p << endl
         <<"p = " << (void *) p << endl
         << "*p = " << *p << endl;

    for(int i = 0 ; i < 5; i++)
    {
        cout << "&a[" << i << "] = "<< (void *)&a[i] << endl;
    }
    return 0;
}

1 #include <iostream>
 2 using namespace std;
 3 
 4 int main()
 5 {
 6     char a[] = "hello";
 7     char *p = a;
 8 
 9     cout << "p = " << p << endl
10          <<"p = " << (void *) p << endl
11          << "*p = " << *p << endl;
12         
13         
14     for(int i = 0 ; i < 5; i++)
15     {
16         cout << "&a[" << i << "] = "<< (void *)&a[i] << endl;
17     }
18     return 0;
19 }

运行结果图如下:

为什么整型指针p输出的是地址,而字符型指针输出的是字符串呢,字符型指针里存放的不是地址吗?

我们先看下内存分配图:

由上图可以看出,其实p中存放的是地址,只是当cout时,如果指针是字符型指针,那么会输出p中地址指向的内存中的内容(这里是h)直到遇到‘\0‘才结束。所以直接输出p时会输出hello,而将p强制转换为void *时输出的是地址。

3. 指向整型指针的指针

先看如下示例:

1 #include <iostream>
using namespace std;

int main()
{
    int a[5] = {1, 2, 3, 4, 5};
    int *p = a;
    int **point = &p;

    cout << "a = " << a << endl
        << "p = " << p << endl
        << "&p = " << &p << endl
        << "point = " << point << endl
        << "&point = " << &point << endl;

    for (int i = 0; i < 5; i++)
    {
        cout << "&a[" << i << "] = " << &a[i] << endl;
    }
    return 0;
}

1 #include <iostream>
 2 using namespace std;
 3 
 4 int main()
 5 {
 6     int a[5] = {1, 2, 3, 4, 5};
 7     int *p = a;
 8     int **point = &p;
 9 
10     cout << "a = " << a << endl
11         << "p = " << p << endl
12         << "&p = " << &p << endl
13         << "point = " << point << endl
14         << "&point = " << &point << endl;
15 
16     for (int i = 0; i < 5; i++)
17     {
18         cout << "&a[" << i << "] = " << &a[i] << endl;
19     }
20     return 0;
21 }

运行结果图如下:

我们先看下内存分配图:

从上图可以看出point指针中存放的是p指针的地址,而p指针中存放的是a[0]的地址。所以*point和p是一样的,前者是取point指针中存放的地址(0025F754)中的值,即取地址0025F754中存放的值(0025F760),而后者就是0025F760,所以两者是等价的。**point和a[0]是等价的,前者可以写成*p,*p是取p中存放的地址(0025F760)中的值,即地址0025F760中存放的值1。由上可以得出*point等于p, **point 等于 a[0]。通过上图可以清晰的对付诸如*point++等问题。

4. 指向整型指针的指针

先看如下示例:

1 #include <iostream>
using namespace std;

int main()
{
    char *a[] = {"Wel", "To", "China"};
    char **p = a;
    for(int i = 0; i < 3; i++)
    {
        for (int j = 0; j < strlen(a[i]) + 1; j++)
        {
            cout << a[i][j] << "\t" << (void *)&a[i][j] << endl;
        }
        cout << endl;
    }

    for (int i = 0; i < 3; i++)
    {
        cout << "a[" << i << "] = " << (void *) a[i] << endl
             << "&a[" << i << "] = " << &a[i] << endl;
    } 

    cout << "p  = " << p << endl
         << "&p = " << &p << endl;
    return 0;
}

1 #include <iostream>
 2 using namespace std;
 3 
 4 int main()
 5 {
 6     char *a[] = {"Wel", "To", "China"};
 7     char **p = a;
 8     for(int i = 0; i < 3; i++)
 9     {
10         for (int j = 0; j < strlen(a[i]) + 1; j++)
11         {
12             cout << a[i][j] << "\t" << (void *)&a[i][j] << endl;
13         }
14         cout << endl;
15     }
16     
17     for (int i = 0; i < 3; i++)
18     {
19         cout << "a[" << i << "] = " << (void *) a[i] << endl
20              << "&a[" << i << "] = " << &a[i] << endl;
21     } 
22 
23 
24     cout << "p  = " << p << endl
25          << "&p = " << &p << endl;
26     return 0;
27 }

运行结果图如下:

我们先看下内存分配图:

由上图可以看出a[0]中存放着‘W‘的地址,a[1]中存放着‘T‘的地址,a[2]中存放着‘C‘的地址,只是这些地址都是指向字符型的,所以直接cout的会输出字符串,而指针p中存放着a[0]的地址,所以*p等于a[0],都是获得‘W‘的地址,即00A778CCC,而**p和a[0][0]等价都获得了地址00A778CCC中存放的值W。由上图我们可以看到字符地址相隔1个字节,而指针地址相隔4个字节,这样就便于++运算,获得下一个地址了,列如++p后,p就指向a[1],p中存放的是a[1]的地址。

时间: 2024-10-10 23:08:31

理解一般指针和指向指针的指针的相关文章

指针常量;常量指针;指向常量的指针常量

三个名词虽然非常绕嘴,不过说的非常准确.用中国话的语义分析就可以很方便地把三个概念区分开. 一) 常量指针. 常量是形容词,指针是名词,以指针为中心的一个偏正结构短语.这样看,常量指针本质是指针,常量修饰它,表示这个指针乃是一个指向常量的指针(变量). 指针指向的对象是常量,那么这个对象不能被更改. 在C/C++中,常量指针是这样声明的: 1)const int *p; 2)int const *p; 常量指针的使用要注意,指针指向的对象不能通过这个指针来修改,可是仍然可以通过原来的声明修改,也

const指针,指向const的指针,指向const的const指针 -- C

int main() { //记忆方法:中间加个"是"字变得很好理解 /* 指针函数 */ void * f(); //按顺序写,先写指针(void *),再写函数(f()) //指针是函数 -- 这个指针是一个函数. /* 函数指针 */ void (* f)(); //函数是指针 -- 这个函数是一个指针. //暂时没想到怎么记忆. /* const 指针 */ const int * a; /* 指向 const 的指针 -- 指针 const*/ int * const b;

指针总结以及常量指针与指向常量的指针与指向常量的常指针

/*指针总结: 1:指针未被初始化一个地址或刚删除一个指针都要将其初始化为0,否则的话将会导致该指针失控 2:假如不想改变一个指针,那么将该指针定义为const, 假如不想改变该指针指向的值,将指针指向的值定义为const 假如即不想改变指针又不想改变指针指向的值,那么将指针和指针指向的值都定义为const 在new堆中创建一个对象,然后将内存地址赋给指针,之后我们就可以通过内存地址访问堆中的对象, 假如要删除该对象,我们只需要使用关键字delete,那么就会删除指针指向的对象并释放存储对象的内

【转】const int *p和int * const p的区别(常量指针与指向常量的指针)

[转]作者:xwdreamer   出处:http://www.cnblogs.com/xwdreamer 对于指针和常量,有以下三种形式都是正确的: const char * myPtr = &char_A;//指向常量的指针 char * const myPtr = &char_A;//常量的指针 const char * const myPtr = &char_A;//指向常量的常量指针 下面依次对这三种类型进行介绍. 因为*操作符是左操作符,左操作符的优先级是从右到左,对于

速记const 指针与指向const的指针

指向const的指针,它的意思是指针指向的内容是不能被修改的.它有两种写法. ` const int* p; (推荐) int const* p;` 再说const指针,它的意思是指针本身的值是不能被修改的.它只有一种写法 int* const p=一个地址; (因为指针本身的值是不能被修改的所以它必须被初始化) 这两种情况很难分清,你只需注意在const后面的是*符号还是变量,*在后说明,const的是指针指向的对象,变量在后说明const的是指针本身 版权声明:本文为博主原创文章,未经博主允

常量指针和指向常量的指针

3种与const.指针及指针指向的对象有关的情形: 1.指向常量对象的指针 2.指向某个对象的常量指针 3.指向常量对象的常量指针 在第一种情况中,我们不能修改被指向的对象,但可以使指针指向其他对象: const char* pstring("Some text"); 在第二种情况中,我们不能修改指针中存储的地址,但可以修改指针指向的对象: char* const pstring("Some text"); 在最后一种情况中,指针和被指向的对象都被定义成常量,因此都

指针常量&amp;指向常量的指针

3 4 #include "stdafx.h" 5 6 int main(int argc, char* argv[]) 7 { 8 int a; 9 int b; 10 int* const p1 = &a; //常量指针,指针不可以改,但是指针指向的内容可以改. 11 const int* p2; //指向常量的指针,指针可以改,但是指针指向的内容不可以改. 12 13 const int c = 3; 14 15 a = 1; 16 b = 2; 17 // p1 = &

指针的内容 &nbsp; 指针的地址 指针所指向的内容 指针的类型 指针所指向的类型

这几个个东东很具有迷惑性. int a=10;      //假设a的地址是 0x0000004C int *p;           //假设p的地址是 0x0035FA94 p=&a; 指针的内容:指针里面存放的是地址. 指针p里面存放的是a的地址(&a).即指针p里面存放的内容是0x0000004C. 指针的地址:指针本身的地址. 指针p的地址就是&p.指针p的地址是0x0035FA94 指针所指向的内容:也就是指针里面存放的地址,那块地址里面存放的内容,通过对指针进行*引用

常指针和指向常量的指针和指向常量的常指针

(1)指向常量的指针:是一个指向的内容是常量的指针变量,const int *p=&x;不可修改*p的内容,但可以让指针p指向另一个地址,和int const *p一样 (2)常指针:int *const p=&x指针本身是个常量,固定指向某一变量,因此p不可变,但是*p可变 (3)指向常量的常指针:const int *const p=&x,指针p永远指向x,并且不能通过它修改它指向的地址的内容

C语言数组指针(指向数组的指针)

注意:数组指针的定义,与指针数组的区别 转载:http://c.biancheng.net/cpp/biancheng/view/162.html 指向多维数组元素的指针变量 ① 指向数组元素的指针变量[例6.7]输出二维数组各元素的值.这里采用的方法是用基类型为整型的指针变量先后指向各元素,逐个输出它们的值. #include <iostream> using namespace std; int main( ) { int a[3][4]={1,3,5,7,9,11,13,15,17,19