一、
C++中引用和指针的区别
指针初始化的时候,可以指向一个地址,也可以为空。
引用必须初始化为另一个变量.
int ival = 1024;
int *pi = &ival; // a pointer
int &rval = ival; // a reference
二、
估计很多人在编写C++程序都或多或少的会用到pointer 和 reference这两种东西,但是他们两者到底有什么样的区别和联系呢,相信大多数人是不太了解的,今天我就两者的区别和联系从实际程序的角度来加以区别。
C/C++中的指针其实就是一个变量,和其他类型的变量是一个样子的,它是一个占用四字节的变量(32位机上),它与其他变量的不同之处就在于它的变量值是一个内存地址,指向内存的另外一个地方。reference我的理解就是一个别名,它和linux操作系统上的alias是一个样子的。再者,一个pointer变量可以指向NULL,表示它不指向任何变量地址,但是reference必须在声明的时候就得和一个已经存在的变量相绑定,而且这种绑定不可改变。下面是我写的一段程序来验证pointer与reference的区别和联系的,希望能对大家理解pointer & reference的区别和联系有所帮助:
#include "stdafx.h"
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
int ival = 1024;
int *pi = &ival; // a pointer
int &rval = ival; // a reference
int jval = 4096;
int xval = 8192;
cout << "ival = " << ival << "/t";
cout << "&ival = " << &ival << "/t";
cout << endl;
cout << "pi = " << pi << "/t";
cout << "&pi = " << &pi << "/t";
cout << "*pi = " << *pi << "/t";
cout << endl;
cout << "rval = " << rval << "/t";
cout << "&rval = " << &rval << "/t";
cout << endl;
cout << "jval = " << jval << "/t";
cout << "&jval = " << &jval << "/t";
cout << endl;
// change the values of the reference and the pointer
pi = &jval;
rval = jval;
// print the changes
cout << endl;
cout << "ival = " << ival << "/t";
cout << "&ival = " << &ival << "/t";
cout << endl;
cout << "pi = " << pi << "/t";
cout << "&pi = " << &pi << "/t";
cout << "*pi = " << *pi << "/t";
cout << endl;
cout << "rval = " << rval << "/t";
cout << "&rval = " << &rval << "/t";
cout << endl;
cout << "jval = " << jval << "/t";
cout << "&jval = " << &jval << "/t";
cout << endl;
cout << endl;
*pi = xval;
cout << "pi = " << pi << "/t";
cout << "&pi = " << &pi << "/t";
cout << "*pi = " << *pi << "/t";
cout << endl;
cout << "jval = " << jval << "/t";
cout << "&jval = " << &jval << "/t";
cout << endl;
return 0;
}
一次的执行结果如下:
ival = 1024 &ival = 0012FF7C
pi = 0012FF7C &pi = 0012FF78 *pi = 1024
rval = 1024 &rval = 0012FF7C
jval = 4096 &jval = 0012FF70
ival = 4096 &ival = 0012FF7C
pi = 0012FF70 &pi = 0012FF78 *pi = 4096
rval = 4096 &rval = 0012FF7C
jval = 4096 &jval = 0012FF70
pi = 0012FF70 &pi = 0012FF78 *pi = 8192
jval = 8192 &jval = 0012FF70
如果有兴趣的话也可以使用其他类型的变量来测试,并且打印出各个变量占用内存的大小,我在这里就不把具体的程序贴出来了。
三、 C++点滴:向函数中传递指针和传递指针的引用的区别:
如果是传递指针,那么回先复制该指针,在函数内部使用的是复制后的指针,这个指针与原来的指针指向相同的地址,如果在函数内部将复制后的指针指向了另外的新的对象,那么不会影响原有的指针;
但是对于传递指针应用,如果将传递进来的指针指向了新的对象,那么原始的指针也就指向了新的对象,这样就会造成内存泄漏,因为原来指针指向的地方已经不能再引用了,即使没有将传递进来的指针指向新的对象,而是在函数结束的时候释放了指针,那么在函数外部就不能再使用原有的指针了,因为原来的内存已经被释放了
对象指针和对象引用
指向类的成员的指针
在C++中,可以说明指向类的数据成员和成员函数的指针。
指向数据成员的指针格式如下:
<类型说明符><类名>::*<指针名>
指向成员函数的指针格式如下:
<类型说明符>(<类名>::*<指针名>)(<参数表>)
例如,设有如下一个类A:
class A
{
public:
int fun (int b) { return a*c+b; }
A(int i) { a=i; }
int c;
private:
int a;
};
定义一个指向类A的数据成员c的指针pc,其格式如下:
int A:: *pc = &A::c;
再定义一个指向类A的成员函数fun的指针pfun,其格式如下:
int (A:: *pfun)(int) = A::fun;
由于类不是运行时存在的对象。因此,在使用这类指针时,需要首先指定A类的一个对象,然后,通过对象来引用指针所指向的成员。例如,给pc指针所指向的数据成员c赋值8,可以表示如下:
A a;
a.*pc = 8;
其中,运算符.*是用来对指向类成员的指针来操作该类的对象的。
如果使用指向对象的指针来对指向类成员的指针进行操作时,使用运算符->*。例如:
A *p = &a; //a是类A的一个对象,p是指向对象a的指针。
p ->* pc = 8;
让我们再看看指向一般函数的指针的定义格式:
<类型说明符>*<指向函数指针名>(<参数表>)
关于给指向函数的指针赋值的格式如下:
<指向函数的指针名>=<函数名>
关于在程序中,使用指向函数的指针调用函数的格式如下:
(*<指向函数的指针名>)(<实参表>)
如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。
下面给出一个使用指向类成员指针的例子:
#include <iostream.h>
class A
{
public:
A(int i) { a=i; }
int fun(int b) { return a*c+b; }
int c;
private:
int a;
};
void main()
{
A x(8); //定义类A的一个对象x
int A::*pc; //定义一个指向类数据成员的指针pc
pc=&A::c; //给指针pc赋值
x.*pc=3; //用指针方式给类成员c赋值为3
int (A::*pfun)(int); //定义一个指向类成员函数的指针pfun
pfun=A::fun; //给指针pfun赋值
A *p=&x; //定义一个对象指针p,并赋初值为x
cout<<(p->*pfun)(5)<<endl; //用对象指针调用指向类成员函数指针pfun指向的函数
}
以上程序定义了好几个指针,虽然它们都是指针,但是所指向的对象是不同的。p是指向类的对象;pc是指向类的数据成员;pfun是指向类的成员函数。因此它们的值也是不相同的。
对象指针和对象引用作函数的参数
1. 对象指针作函数的参数
使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处:
(1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值,实现函数之间的信息传递。
(2) 使用对象指针实参仅将对象的地址值传给形参,而不进行副本的拷贝,这样可以提高运行效率,减少时空开销。
当形参是指向对象指针时,调用函数的对应实参应该是某个对象的地址值,一般使用&后加对象名。下面举一例子说明对象指针作函数参数。
#include <iostream.h>
class M
{
public:
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M *m);
void setxy(int i, int j) { x=i; y=j; }
void print() { cout<<x<<","<<y<<endl; }
private:
int x, y;
};
void M::copy(M *m)
{
x=m->x;
y=m->y;
}
void fun(M m1, M *m2);
void main()
{
M p(5, 7), q;
q.copy(&p);
fun(p, &q);
p.print();
q.print();
}
void fun(M m1, M *m2)
{
m1.setxy(12, 15);
m2->setxy(22,25);
}
输出结果为:
5,7
22,25
从输出结果可以看出,当在被调用函数fun中,改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2->setxy(22, 25)]以后,可以看到只有指向对象指针作参数所指向的对象被改变了,而另一个对象作参数,形参对象值改变了,可实参对象值并没有改变。因此输出上述结果。
2. 对象引用作函数参数
在实际中,使用对象引用作函数参数要比使用对象指针作函数更普遍,这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点,而用对象引用作函数参数将更简单,更直接。所以,在C++编程中,人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。
#include <iostream.h>
class M
{
public:
M() { x=y=0; }
M(int i, int j) { x=i; y=j; }
void copy(M &m);
void setxy(int i, int j) { x=i; y=j; }
void print() {cout<<x<<","<<y<<endl; }
private:
int x, y;
};
void M::copy(M &m)
{
x=m.x;
x=m.y;
}
void fun(M m1, M &m2);
void main()
{
M p(5, 7), q;
q.copy(p);
fun(p, q);
p.print();
q.print();
}
void fun(M m1, M &m2)
{
m1.setxy(12, 15);
m2.setxy(22, 25);
}
该例子与上面的例子输出相同的结果,只是调用时的参数不一样。
3、this指针
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。
当对一个对象调用成员函数时,编译程序先将对象的地址赋给this指针,然后调用成员函数,每次成员函数存取数据成员时,由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include <iostream.h>
class A
{
public:
A() { a=b=0; }
A(int i, int j) { a=i; b=j; }
void copy(A &aa); //对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa)
{
if (this == &aa) return; //这个this是操作该成员函数的对象的地址,在这里是对象a1的地址
*this = aa; //*this是操作该成员函数的对象,在这里是对象a1。
//此语句是对象aa赋给a1,也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1.copy(a2);
a1.print();
}
运行结果:
3, 4
指针与引用的区别
指针与引用看上去完全不同(指针用操作符’*’和’->’,引用使用操作符’.’),但是它们似乎有相同的功能。指针与引用都是让你间接引用其他对象。你如何决定在什么时候使用指针,在什么时候使用引用呢?
首先,要认识到在任何情况下都不能用指向空值的引用。一个引用必须总是指向某些对象。因此如果你使用一个变量并让它指向一个对象,但是该变量在某些时候也可能不指向任何对象,这时你应该把变量声明为指针,因为这样你可以赋空值给该变量。相反,如果变量肯定指向一个对象,例如你的设计不允许变量为空,这时你就可以把变量声明为引用。
“但是,请等一下”,你怀疑地问,“这样的代码会产生什么样的后果?”
char *pc = 0; // 设置指针为空值
char& rc = *pc; // 让引用指向空值
这是非常有害的,毫无疑问。结果将是不确定的(编译器能产生一些输出,导致任何事情都有可能发生),应该躲开写出这样代码的人除非他们同意改正错误。如果你担心这样的代码会出现在你的软件里,那么你最好完全避免使用引用,要不然就去让更优秀的程序员去做。我们以后将忽略一个引用指向空值的可能性。
因为引用肯定会指向一个对象,在C里,引用应被初始化。
string& rs; // 错误,引用必须被初始化
string s("xyzzy");
string& rs = s; // 正确,rs指向s指针没有这样的限制。
string *ps; // 未初始化的指针,合法但危险
不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针的要高。因为在使用引用之前不需要测试它的合法性。
void printDouble(const double& rd)
{
cout << rd; // 不需要测试rd,它
} // 肯定指向一个double值
相反,指针则应该总是被测试,防止其为空:
void printDouble(const double *pd)
{
if (pd)
{// 检查是否为NULL
cout << *pd;
}
}
指针与引用的另一个重要的不同是指针可以被重新赋值以指向另一个不同的对象。但是引用则总是指向在初始化时被指定的对象,以后不能改变。
string s1("Nancy");
string s2("Clancy");
string& rs = s1; // rs 引用 s1
string *ps = &s1; // ps 指向 s1
rs = s2; // rs 仍旧引用s1
// 但是 s1的值现在是"Clancy"
ps = &s2; // ps 现在指向 s2;// s1 没有改变
总的来说,在以下情况下你应该使用指针,一是你考虑到存在不指向任何对象的可能(在这种情况下,你能够设置指针为空),二是你需要能够在不同的时刻指向不同的对象(在这种情况下,你能改变指针的指向)。如果总是指向一个对象并且一旦指向一个对象后就不会改变指向,那么你应该使用引用。
还有一种情况,就是当你重载某个操作符时,你应该使用引用。最普通的例子是操作符[]。这个操作符典型的用法是返回一个目标对象,其能被赋值。
vector<int> v(10); //建立整形向量(vector),大小为10
//向量是一个在标准C库中的一个模板(见条款35)
v[5] = 10; // 这个被赋值的目标对象就是操作符[]返回的值
如果操作符[]返回一个指针,那么后一个语句就得这样写:
*v[5] = 10;
但是这样会使得v看上去象是一个向量指针。因此你会选择让操作符返回一个引用。(这有一个有趣的例外,参见条款30)
当你知道你必须指向一个对象并且不想改变其指向时,或者在重载操作符并为防止不必要的语义误解时,你不应该使用指针。而在除此之外的其他情况下,则应使用指针 。