C++ 引用 解引用 取地址 指针 双指针 指针的引用 二级指针
2014-12-05 15:17
357 查看
为了把引用 解引用 取地址 指针 双指针 指针的引用 二级指针 这一块弄清楚,钻研与查阅资料得到如下体会;
1. 引用与取地址 (reference and address) 引用的&前面一定有类型符号,否则就不是引用, 取地址的&后面一定有变量名称,一旦出现&,一定把此搞明白
int b =10, int &a, 这明显就是引用,&b 这就是取地址, test1(int &a, int &b) 这些是引用用在定义函数的时候, test4(&a, &b) 这个时候是取地址,&后面必须是变量名字,不能是其它的,比如&*b是不容许的,
2. 引用是变量的别名,与变量有相同的地址和值, & 只在定义的时候出现,以后不用出现, int &a =b, 以后直接在使用的时候用a 代表b, 不是用&a 代表b (单独出现&a,此时就是应用的地址了, 它就是b的地址) &a==&b,地址是相等的。函数中如传递变量, f(b), 如需要传递变量的地址f(&b)
3. 一个变量(包括指针)包括三个部分, 变量名字, 变量的值, 变量的地址,内存中地址是唯一的, 生命周期内名字和地址是关联的,多个名字可关联一个地址,值是地址上的储存内容,可以变的,名字没有直接和值关联,名字关联地址,地址在关联值, 这三个是三回事,地址和引用,地址,解引用就是解决此三部分不同的问题。
一般的赋值等是对变量的值赋值,而不是地址等其他的, int b=10, 是b的值赋为10, 而不是地址 int *f , f=&b, 这是把指针的值赋为b的地址,而指针f本省的地址没有涉及
4. 指针与解引用 (pointer and dereference) 指针的*前面一定有类型符号,否则就不是指针, 解引用的*后面一定要有地址(指针或相当于值是地址的变量)一旦出现×,一定高明, int * f, 只是指针定义, 而如果单独出现 *f 这个时候是解引用, test8(int ×a, int ×b) 这些是指针用在定义函数的时候, test9(×a, ×b) 这个时候是解引用,传递的指针对应的解引用, ×&f 这个就是变量f的地址的解引用,就是变量f的值
5 . 指针里面的值是变量的地址, × 只在定义的时候出现,以后不出现, int*f, f=&b, 以后直接用f 代表 &b, 用*f(解引用)代表b, 代表是可以写等于的意思。而不是以后也用*f=&b, f=b.
6. 指针就是变量本身储存的值是另一个变量的地址, 和它本身的地址是两回事, 解引用是指针的值(地址)作为另一个变量的地址, 这个地址对应的值。int *f =&b,
此时f的地址是:HHH, f的值是AAA, b的地址是AAA, b的值是CCC, HHH 就是&f, ×f 就是CCC。二级指针就是指向指针的指针,相当于这里的CCC又是一个变量的地址,
7. 作为参数传递等的时候,一定要抛开类新定义时前两*或&的符号,左边的值与右边建立对等关系 ,左边值是地址,右边就是地址,左边值是值, 右边也就是普通的值, 如 fee(int* f), int k, 在实参引用的时候要fee(&h), 不能fee(h), 因为定义中*是类型符号,f的值是地址, 要与&h才一直, fee(int &h) , int k, 在实参引用的时候要fee(k). 因为&是类型符,h是引用,值和变量一样, 而不能是地址参数fee(&h)
8. 引用不分配内存, 而指针分配, int d, int& f=d,, int *u =&d , 此时d和f 的值, 地址一模一样,u的值和d的地址上一样, u有它自己的地址。
9. 作为参数传递,指针作为参数的时候是临时拷贝一个副本( 不同的地址),它的值和原来的指针一样,及指向的地址和原来的指针指向的一样,他们有相同的解引用,因此对函数内这个临时指针的值的操作都不会影响到原来的指针,只是把临时指针的值变了,及指的地址变了,如果不对这个临时指针操作,而对它的解引用操作, 由于和原来的指针指向同一个地址,有相同的解引用,因此对临时指针的解引用操作会影响到原来的解引用,要在函数退出后而使原来的值的变化有保留,就必须把要改变的值放在传递指针的解引用里面。 要想让指针作为参数在函数中操作完后有变化有保留,因此要让产生的临时指针指向这个指针的地址,临时指针的解引用就是这个指针,临时指针的解引用变化,这个指针的值就变化,这个指针的解引用,和临时指针的解引用的解引用一致,就是二级指针或双指针。及指针用作参数传出时需要二级指针。
int *a=&b,
int c*=&d,
exchange(int*f, int*e),
{
int * temp
temp =f;
f=e,
e=temp
}
exchange(a, c)
执行时;
f 是一个临时指针指向b的地址, *f就是b 函数外a 指向b的地址
e是一个临时指针指向d的地址, *e就是d 函数外c指向d的地址
交换后
f 是一个临时指针指向d的地址, *f就是d 函数外a 指向b的地址
e是一个临时指针指向b的地址, *e就是b 函数外c指向d的地址
因此函数内部变了,外部没有变, 退出后还是原样子。
如果是
exchange(int*f, int*e),
{
int temp
temp =*f;
*f=*e,
*e=temp
}
exchange(a, c)
此时执行
f 是一个临时指针指向b的地址, *f就是b 函数外a 指向b的地址 *a就是b
e是一个临时指针指向d的地址, *e就是d 函数外c指向d的地址 *c就是d
交换后
f 是一个临时指针指向b的地址, *f就是d 函数外a 指向b的地址 *a就是b 但此时 b的值变成d的值了, b的名称和地址没有变
e是一个临时指针指向d的地址, *e就是b 函数外c指向d的地址 *c就是d 但此时 d的值变成b的值了 d的名称和地址没有变
如前名称和地址是绑定的, 这次是把值变了
如果是
exchange(int**f, int**e),
{
int * temp
temp =*f;
*f=*e,
*e=temp
}
exchange(&a, &c) 注意此时格式
执行时
f 是一个临时指针指向指针a的地址, *f就是a, * a就是b, **f就是 b, 函数外a 指向b的地址 *a就是b
e是一个临时指针指向指针c的地址, *e就是c *c就是d, **e就是 d 函数外c指向d的地址 *c就是d
执行后
f 是一个临时指针指向指针a的地址, *f就是a, 此时a的名称和地址没有变,但值变成了c的值 * a就指向* c 即 d, **f就是 d, 函数外a 指向d的地址 *a就是d
e是一个临时指针指向指针c的地址, *e就是c 此时c的名称和地址没有变, 但值变成a的值, *c就指向*a 即 b, **e就是 b 函数外c指向d的地址 *c就是b
这样的操作是在指针的值的层面上做了交换,上面一种是在原数据基础上做了交换。
10. 引用作为参数,是直接把实参的地址和值当作引用的,起了个别名,相当于给这段地址关联了一个名字,相比指针少了一个临时的指针的地址。因此函数内部对别名的操作就相当于对原实参操作。
exchange(int &f, int &e),
{
int temp
temp =f;
f=e,
e=temp
}
exchange(b, d)
执行时
f 的值是b, f的地址是b 的地址
e的值是d, e的地址是 d 的地址
执行后
f的值是c的值, f 的地址还是原来b的地址 b的地址中变成c的值了
e的值变为d的值, e的地址还是原来b的地址, c的地址中变成b的值了,
在数值层面上交换了。
11. 引用和指针相结合,产生了指针类型的引用 int *&f 它的意思是f和一个指针有相同的地址和值。
exchange(int *&f, int *&e),
{
int temp
temp =f;
f=e,
e=temp
}
exchange(a, c) 注意里面一定要指针
执行时 f 就相当于指针 a
e 就相当于指针c,
这样相当于把外面指针直接拿到函数内使用了。 比刚才二级指针效率提升了许多。
引申
一般的情况是
二级指针------> 一级指针---->原数据
要想原数据改变有多种方式
直接改变
利用一级指针做中介 改变一级指针的解引用
利用二级指针做中介,改变二级指针的解引用, 此时绑定一级指针值和原数据,
使用指针作为中介的地方都可直接使用引用。去掉中介。
-------------
1. 引用与取地址 (reference and address) 引用的&前面一定有类型符号,否则就不是引用, 取地址的&后面一定有变量名称,一旦出现&,一定把此搞明白
int b =10, int &a, 这明显就是引用,&b 这就是取地址, test1(int &a, int &b) 这些是引用用在定义函数的时候, test4(&a, &b) 这个时候是取地址,&后面必须是变量名字,不能是其它的,比如&*b是不容许的,
2. 引用是变量的别名,与变量有相同的地址和值, & 只在定义的时候出现,以后不用出现, int &a =b, 以后直接在使用的时候用a 代表b, 不是用&a 代表b (单独出现&a,此时就是应用的地址了, 它就是b的地址) &a==&b,地址是相等的。函数中如传递变量, f(b), 如需要传递变量的地址f(&b)
3. 一个变量(包括指针)包括三个部分, 变量名字, 变量的值, 变量的地址,内存中地址是唯一的, 生命周期内名字和地址是关联的,多个名字可关联一个地址,值是地址上的储存内容,可以变的,名字没有直接和值关联,名字关联地址,地址在关联值, 这三个是三回事,地址和引用,地址,解引用就是解决此三部分不同的问题。
一般的赋值等是对变量的值赋值,而不是地址等其他的, int b=10, 是b的值赋为10, 而不是地址 int *f , f=&b, 这是把指针的值赋为b的地址,而指针f本省的地址没有涉及
4. 指针与解引用 (pointer and dereference) 指针的*前面一定有类型符号,否则就不是指针, 解引用的*后面一定要有地址(指针或相当于值是地址的变量)一旦出现×,一定高明, int * f, 只是指针定义, 而如果单独出现 *f 这个时候是解引用, test8(int ×a, int ×b) 这些是指针用在定义函数的时候, test9(×a, ×b) 这个时候是解引用,传递的指针对应的解引用, ×&f 这个就是变量f的地址的解引用,就是变量f的值
5 . 指针里面的值是变量的地址, × 只在定义的时候出现,以后不出现, int*f, f=&b, 以后直接用f 代表 &b, 用*f(解引用)代表b, 代表是可以写等于的意思。而不是以后也用*f=&b, f=b.
6. 指针就是变量本身储存的值是另一个变量的地址, 和它本身的地址是两回事, 解引用是指针的值(地址)作为另一个变量的地址, 这个地址对应的值。int *f =&b,
此时f的地址是:HHH, f的值是AAA, b的地址是AAA, b的值是CCC, HHH 就是&f, ×f 就是CCC。二级指针就是指向指针的指针,相当于这里的CCC又是一个变量的地址,
7. 作为参数传递等的时候,一定要抛开类新定义时前两*或&的符号,左边的值与右边建立对等关系 ,左边值是地址,右边就是地址,左边值是值, 右边也就是普通的值, 如 fee(int* f), int k, 在实参引用的时候要fee(&h), 不能fee(h), 因为定义中*是类型符号,f的值是地址, 要与&h才一直, fee(int &h) , int k, 在实参引用的时候要fee(k). 因为&是类型符,h是引用,值和变量一样, 而不能是地址参数fee(&h)
8. 引用不分配内存, 而指针分配, int d, int& f=d,, int *u =&d , 此时d和f 的值, 地址一模一样,u的值和d的地址上一样, u有它自己的地址。
9. 作为参数传递,指针作为参数的时候是临时拷贝一个副本( 不同的地址),它的值和原来的指针一样,及指向的地址和原来的指针指向的一样,他们有相同的解引用,因此对函数内这个临时指针的值的操作都不会影响到原来的指针,只是把临时指针的值变了,及指的地址变了,如果不对这个临时指针操作,而对它的解引用操作, 由于和原来的指针指向同一个地址,有相同的解引用,因此对临时指针的解引用操作会影响到原来的解引用,要在函数退出后而使原来的值的变化有保留,就必须把要改变的值放在传递指针的解引用里面。 要想让指针作为参数在函数中操作完后有变化有保留,因此要让产生的临时指针指向这个指针的地址,临时指针的解引用就是这个指针,临时指针的解引用变化,这个指针的值就变化,这个指针的解引用,和临时指针的解引用的解引用一致,就是二级指针或双指针。及指针用作参数传出时需要二级指针。
int *a=&b,
int c*=&d,
exchange(int*f, int*e),
{
int * temp
temp =f;
f=e,
e=temp
}
exchange(a, c)
执行时;
f 是一个临时指针指向b的地址, *f就是b 函数外a 指向b的地址
e是一个临时指针指向d的地址, *e就是d 函数外c指向d的地址
交换后
f 是一个临时指针指向d的地址, *f就是d 函数外a 指向b的地址
e是一个临时指针指向b的地址, *e就是b 函数外c指向d的地址
因此函数内部变了,外部没有变, 退出后还是原样子。
如果是
exchange(int*f, int*e),
{
int temp
temp =*f;
*f=*e,
*e=temp
}
exchange(a, c)
此时执行
f 是一个临时指针指向b的地址, *f就是b 函数外a 指向b的地址 *a就是b
e是一个临时指针指向d的地址, *e就是d 函数外c指向d的地址 *c就是d
交换后
f 是一个临时指针指向b的地址, *f就是d 函数外a 指向b的地址 *a就是b 但此时 b的值变成d的值了, b的名称和地址没有变
e是一个临时指针指向d的地址, *e就是b 函数外c指向d的地址 *c就是d 但此时 d的值变成b的值了 d的名称和地址没有变
如前名称和地址是绑定的, 这次是把值变了
如果是
exchange(int**f, int**e),
{
int * temp
temp =*f;
*f=*e,
*e=temp
}
exchange(&a, &c) 注意此时格式
执行时
f 是一个临时指针指向指针a的地址, *f就是a, * a就是b, **f就是 b, 函数外a 指向b的地址 *a就是b
e是一个临时指针指向指针c的地址, *e就是c *c就是d, **e就是 d 函数外c指向d的地址 *c就是d
执行后
f 是一个临时指针指向指针a的地址, *f就是a, 此时a的名称和地址没有变,但值变成了c的值 * a就指向* c 即 d, **f就是 d, 函数外a 指向d的地址 *a就是d
e是一个临时指针指向指针c的地址, *e就是c 此时c的名称和地址没有变, 但值变成a的值, *c就指向*a 即 b, **e就是 b 函数外c指向d的地址 *c就是b
这样的操作是在指针的值的层面上做了交换,上面一种是在原数据基础上做了交换。
10. 引用作为参数,是直接把实参的地址和值当作引用的,起了个别名,相当于给这段地址关联了一个名字,相比指针少了一个临时的指针的地址。因此函数内部对别名的操作就相当于对原实参操作。
exchange(int &f, int &e),
{
int temp
temp =f;
f=e,
e=temp
}
exchange(b, d)
执行时
f 的值是b, f的地址是b 的地址
e的值是d, e的地址是 d 的地址
执行后
f的值是c的值, f 的地址还是原来b的地址 b的地址中变成c的值了
e的值变为d的值, e的地址还是原来b的地址, c的地址中变成b的值了,
在数值层面上交换了。
11. 引用和指针相结合,产生了指针类型的引用 int *&f 它的意思是f和一个指针有相同的地址和值。
exchange(int *&f, int *&e),
{
int temp
temp =f;
f=e,
e=temp
}
exchange(a, c) 注意里面一定要指针
执行时 f 就相当于指针 a
e 就相当于指针c,
这样相当于把外面指针直接拿到函数内使用了。 比刚才二级指针效率提升了许多。
引申
一般的情况是
二级指针------> 一级指针---->原数据
要想原数据改变有多种方式
直接改变
利用一级指针做中介 改变一级指针的解引用
利用二级指针做中介,改变二级指针的解引用, 此时绑定一级指针值和原数据,
使用指针作为中介的地方都可直接使用引用。去掉中介。
-------------
相关文章推荐
- C/C++中关于地址、指针和引用变量的学习笔记(八) : 命令行参数
- C/C++中关于地址、指针和引用变量的学习笔记(九) : 内存结构
- C/C++【初级】之一 指针(*)、取地址(&)、解引用(*)与引用(&)的概念
- 详解C++中指针(*)、取地址(&)、解引用(*)与引用(&)的区别 (完整代码)
- C/C++中关于地址、指针和引用变量的学习笔记(五) : 指针
- 详解C++中指针(*)、取地址(&)、解引用(*)与引用(&)的区别
- 详解C++中指针(*)、取地址(&)、解引用(*)与引用(&)的区别 (完整代码)
- C++指针与地址引用
- 详解C++中指针(*)、取地址(&)、解引用(*)与引用(&)的区别 (完整代码)
- C/C++中关于地址、指针和引用变量的学习笔记(七) : sizeof和typedef
- 详解C++中指针(*)、取地址(&)、解引用(*)与引用(&)的区别 (完整代码)
- C/C++中关于地址、指针和引用变量的学习笔记(六) : const和void
- C++中的指针,地址和引用
- C/C++中关于地址、指针和引用变量的学习笔记(二) : 数组
- C/C++中关于地址、指针和引用变量的学习笔记(三) : 结构
- c++中变量、变量名、变量地址、指针、引用等含义
- 详解C++中指针(*)、取地址(&)、解引用(*)与引用(&)的区别
- 二级指针和指针引用函数传参(C++)
- 详解C++中指针(*)、取地址(&)、解引用(*)与引用(&)的区别 (完整代码)
- c++按地址传参–指针和引用