多级指针与引用

多级指针与引用
多级指针与引用

字符串的三种表达方式:

1.char str[10]="hello";

2.string str="hello";

3.char *p="hello";

多个字符串的表达方式:

1.char str[5][10]={"helloe","hhj","daa","ddd","aheh"};

#include

using namespace std;

int main()

{

char str[5][10]={"helloe","hhj","daa","ddd","aheh"};

int i;

for(i=0;i<5;i++)

cout<

return 0;

}

2.string str[5]={"helloe","hhj","daa","ddd","aheh"};

#include

#include

using namespace std;

int main()

{

string str[5]={"helloe","hhj","daa","ddd","aheh"};

int i;

for(i=0;i<5;i++)

cout<

return 0;

}

3.char *str[5]={"helloe","hhj","daa","ddd","aheh"};

#include

using namespace std;

int main()

{

char *str[5]={"helloe","hhj","daa","ddd","aheh"};

int i;

for(i=0;i<5;i++)

cout<

return 0;

}

整形一维数组中两个元素的交换(通过函数实现)void swap(int *p,int *q)

{

*p=*q;

*q=t;

}

int main()

{

int a[5]={1,3,2,5,4};

swap(&a[0],&a[1]);//将数组中元素的地址传递给形参,通过形参:指针变量来接受数组元素的地址,从而在被调函数中通过指针变量间接访问主调函数中的数据

。。。。

}

void swap(int *p,int *q)

{

int t=*p;

*p=*q;

*q=t;

}//交换的是*p(代表a[0]和*q代表a[1]的值)

指向指针的指针变量:指针变量,该指针变量中存放的是一个指针变量的地址或该指针变量指向的目标是一个指针

定义的一般形式:

类型**指针变量名;

如果有:char **p;//p与右侧的*结合表示是一个指针变量,剩余部分就是p所指向目标的类型

p=&变量;该变量类型应该是char *

int main()

{

int a[5]={1,2,3,4,5};

int *b[5]={a,a+1,a+2,a+3,a+4};

for(int i=0;i<5;i++)

cout<<*b[i]<<" ";

int **p=b;

for(;p

cout<<**p;

return 0;

}

#include

using namespace std;

void swap(char **p, char **q)

{

char *t=*p;

*q=t;

}

int main()

{

char *str[5]={"helloe","hhj","daa","ddd","aheh"};

int i,j;

int a[5]={1,3,2,5,4};

swap(&a[0],&a[1]);

for(i=1;i<5;i++)

for(j=0;j<5-i;j++)

if(strcmp(str[j],str[j+1])>0)

swap(&str[j],&str[j+1]);

for(i=0;i<5;i++)

cout<

return 0;

}

指向常量的指针:

定义的一般形式:const 类型名*指针变量名;(const int *p;p可变,*p不可变) 常指针:

定义的一般形式:类型名* const 指针变量名;(int *const p;p不可变,*p可变) 指向常量的常指针:

定义的一般形式:const 类型名*const 指针变量名;

引用

#include

using namespace std;

int main()

{

int a;

int &b=a;

b=4;

cout<

return 0;

}

引用作为参数:

#include

using namespace std;

void swap(int &p,int &q)

{

int t=p;

p=q;

q=t;

}

int main()

{

int a,b;

a=3,b=4;

swap(a,b);

cout<

return 0;

}

C++中引用传递与指针传递区别

C++中引用传递与指针传递区别(进一步整理) 从概念上讲。指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。 而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量)。 在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的: 指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变)而在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。 引用传递和指针传递是不同的,虽然它们都是在被调函数栈空间上的一个局部变量,但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数,如果改变被调函数中的指针地址,它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量,那就得使用指向指针的指针,或者指针引用。 为了进一步加深大家对指针和引用的区别,下面我从编译的角度来阐述它们之间的区别: 程序在编译时分别将指针和引用添加到符号表上,符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值,而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改,因此指针可以改变其指向的对象(指针变量中的值可以改),而引用对象则不能修改。 最后,总结一下指针和引用的相同点和不同点: ★相同点: ●都是地址的概念; 指针指向一块内存,它的内容是所指内存的地址;而引用则是某块内存的别名。 ★不同点: ●指针是一个实体,而引用仅是个别名; ●引用只能在定义时被初始化一次,之后不可变;指针可变;引用“从一而终”,指针可以“见异思迁”;

C++程序设计 第八章 指针和引用

C++程序设计 第8章指针和引用 在程序运行时变量和函数都存放在内存中,通过变量名来访问数据、通过函数名来调用函数都是直接访问方式。还有另一种间接访问方式就是用指针。指针的本质是内存地址。指针往往用于说明函数的形参,使实参能通过指针传递,以提高函数调用的效率。利用指针能动态地使用内存,以提高内存使用效率。指针也能用来表示数据关联,以构成复杂的数据结构。指针是C程序中最常见的类型。引用是C++扩展的新概念,主要用于函数形参和返回类型。本章将详细介绍指针和引用的概念及应用。 8.1 指针及指针变量 指针(pointer)的本质是内存地址。指针变量就是专门存储地址的一种变量。通过指针变量所存储的地址来访问数据是一种间接寻址方式。由于处理器的机器语言能支持间接寻址,所以使用指针可以达到较高的计算性能。 8.1.1 地址的概念 C++编译器对不同对象或变量按其数据类型分配合适大小的存储空间。例如为char或bool型变量分配1个字节(bytes)的存储空间,short分配2字节,int和float分配4个字节,为double型变量分配8个字节的存储空间。当程序执行时,代码和变量都加载到内存中。计算机内存被分成若干个存储单元,存储单元以字节为单位。每个存储单元都有一个固定的编号,这个编号就是内存地址。尽管一个变量可能占用多个字节空间,但都通过第一个字节的地址来访问。存放某个变量的第一个字节的地址就是该数据的首地址。 指针即内存单元的地址,而数据是内存单元中的内容(或值)。 假设在程序中说明了1个int型的变量a,其值为68。系统为变量a分配4字节的存储空间,设首地址为0X0065FDF4。通过地址0X0065FDF4就能找到变量a在内存中的存储单元,从而对变量a进行访问。0X0065FDF4就是变量a的指针。知道一个变量的地址和变量的类型就能对变量进行访问,就如同知道房间号就能找到房间,从而找到房间里的主人。 指针是一种特殊的数据类型。所有类型的变量,无论是基本类型、用户定义类型、还是这些类型的数组,在一次运行时都有确定的地址,因此它们都有指针。对于32位计算机,地址长度就是32位,因此一个指针需要4个字节,与整型int、浮点型float具有相同大小的长度。一个指针不仅有值,而且还要确定其类型,表示它能指向什么类型的数据,决定了通过它要取用多少字节作为该变量的值。

C 引用与指针的比较

C 引用与指针的比较 引用是C 中的概念,初学者容易把引用和指针混淆一起。 一下程序中,n是m的一个引用(reference),m是被引用物(referent)。 int m; int &n = m; n相当于m的别名(绰号),对n的任何操作就是对m的操作。 所以n既不是m的拷贝,也不是指向m的指针,其实n就是m它自己。 引用的规则: (1)引用被创建的同时必须被初始化(指针则可以在任何时候被初始化)。 (2)不能有NULL引用,引用必须与合法的存储单元关联(指针则可以是NULL)。 (3)一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)。 以下示例程序中,k被初始化为i的引用。 语句k = j并不能将k修改成为j的引用,只是把k的值改变成为6。 由于k是i的引用,所以i的值也变成了6。 int i = 5; int j = 6; int &k = i; k = j; // k和i的值都变成了6; 引用的主要功能是传递函数的参数和返回值。 C 语言中,函数的参数和返回值的传递方式有三种:值传递、指针传递和引用传递。 以下是"值传递"的示例程序。 由于Func1函数体内的x是外部变量n的一份拷贝,改变x的值不会影响n, 所以n的值仍然是0。 void Func1(int x) { x = x 10; } ... int n = 0; Func1(n); cout << "n = " << n << endl; // n = 0 以下是"指针传递"的示例程序。 由于Func2函数体内的x是指向外部变量n的指针,改变该指针的内容将导致n的值改变,所以n的值成为10。

指针与引用的区别(非常经典)

c++中,引用和指针的区别 (1)引用总是指向一个对象,没有所谓的null reference .所有当有可能指向一个对象也由可能不指向对象则必须使用指针. 由于C++ 要求reference 总是指向一个对象所以reference要求有初值. String & rs = string1; 由于没有所谓的null reference 所以所以在使用前不需要进行测试其是否有值.,而使用指针则需要测试其的有效性. (2)指针可以被重新赋值而reference则总是指向最初或地的对象. (3)必须使用reference的场合. Operator[] 操作符由于该操作符很特别地必须返回[能够被当做assignment 赋值对象] 的东西,所以需要给他返回一个reference. (4)其实引用在函数的参数中使用很经常. void Get***(const int& a) //这样使用了引用有可以保证不修改被引用的值 { } 引用和指针 ★相同点: 1. 都是地址的概念; 指针指向一块内存,它的内容是所指内存的地址;引用是某块内存的别名。 ★区别: 1. 指针是一个实体,而引用仅是个别名; 2. 引用使用时无需解引用(*),指针需要解引用; 3. 引用只能在定义时被初始化一次,之后不可变;指针可变; 引用“从一而终” ^_^ 4. 引用没有const,指针有const,const 的指针不可变; 5. 引用不能为空,指针可以为空; 6. “sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小; typeid(T) == typeid(T&) 恒为真,sizeof(T) == sizeof(T&) 恒为真, 但是当引用作为成员时,其占用空间与指针相同(没找到标准的规定)。

C 指针、引用详解

C++指针、引用详解.txt用快乐去奔跑,用心去倾听,用思维去发展,用努力去奋斗,用目标去衡量,用爱去生活。钱多钱少,常有就好!人老人少,健康就好!家贫家富,和睦就好。指针、引用与指针引用传值详解:(下文定义形式中的p都是标识符名,读者可自行修改) 1.指向常量的指针 可以改变指针指向哪个对象,但是不能改变指向对象的值 定义形式: (const int*) p; (int const*) p; //括号可以省去 测试内容: -------------------- int a = 10; const int b = 2; const int* test_p; test_p = &b; //正确,指向常量的指针可以指向常量 test_p = &a; //正确,这里隐式转换:test_p = (const int *)&a;(如果是从const int* 转换到int或者const int 的话,需要显式转换) *test_p = 3;//错误,不能尝试修改所指的对象的值 a++; cout<<*test_p;//将输出11(上一语句虽然不能用*test_p++来修改所指向的对象a,但是由于a是变量,直接对变量进行修改后,指针值*test_p也就指向a++的值了) //这种方法少用,造成用法不明确性 --------------------- //另加: 如果有 int *p; const int b = 2; p = &b;//错误,b是常量,普通指针不能指向常量,这是C++为了保证常量的只读性(毕竟如果p能指向b,那么根据定义*p的值就可以修改,这与常量不能重定义和修改矛盾) --------------------- 2.指针常量 可以改变指向对象的值,但不能改变指向的对象。 定义形式:

指针和引用

指针与引用看上去完全不同(指针用操作符“*”和“->”,引用使用操作符“. ”),但是它们似乎有相同的功能。指针与引用都是让你间接引用其他对象。你如何决定在什么时候使用指针,在什么时候使用引用呢? 首先,要认识到在任何情况下都不能使用指向空值的引用。一个引用必须总是指向某些对象。因此如果你使用一个变量并让它指向一个对象,但是该变量在某些时候也可能不指向任何对象,这时你应该把变量声明为指针,因为这样你可以赋空值给该变量。相反,如果变量肯定指向一个对象,例如你的设计不允许变量为空,这时你就可以把变量声明为引用。 “但是,请等一下”,你怀疑地问,“这样的代码会产生什么样的后果?” 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"

实验9 指针与引用

C++程序设计实验报告 学号姓名系别班级计科专教师实验日期同组成员 一、实验编号及名称:实验9 指针与引用 二、实验目的: 1.要求能够使用指针,能够用指针给函数传递参数; 2.理解指针、数组和字符串之间的紧密联系,能够声明和使用字符串数组; 3.掌握引用的语法,用引用传递函数的方法。 三、实验内容及要求 1.P168 ch8_17字符指针的操作 2. P172 ch8_20把一个字符指针数组传递给函数 3. P179 ch8_24(函数指针用作函数参数)计算以0.10为步长,特定范围内的三角函数之和 4.P187 ch9_3给引用赋新值 5.P164 ch8_13用指针实现两个数据交换 P190 ch9_4用引用实现两个数据交换 6. P190 ch9_5 用引用实现函数返回两个值。 四、实验材料、工具、或软件:VC++6.0 五、实验步骤(或记录) 1. 程序如下: #include int main() { char buffer[10]="ABC"; char *pc; pc="hello"; cout<

2.编写的程序如下: #include void Print(char*[],int); void main() { char* pn[]={"Fred","Barney","Wilma","Betty"}; int num =sizeof(pn)/sizeof(char*); Print(pn,num); } void Print(char* arr[], int len) { for(int i=0; i #include double sigma(double(*func)(double),double dl,double du) { double dt=0.0; for(double d=dl; d

引用和用指针的区别

引用和用指针的区别 在c++函数中,形式参数用引用和用指针都可以起到在被调用函数中改变调用函数的变量的作用。什么时候用引用作参数什么时候用指针作参数呢 void function (int *ptr); void function(int &ref); 没有特定的规定。。学的久了,就会习惯什么时候用指针什么时候用引用了引用与指针有什么区别? 1) 引用必须被初始化,指针不必。 2) 引用初始化以后不能被改变,指针可以改变所指的对象。 2) 不存在指向空值的引用,但是存在指向空值的指针。 C++中尽量用引用。个人觉得所有的引用都可以用指针,但指针比引用容易出错。 引用当然更直观更直接,做参数时,如果在函数内不刻意要用指针的那些副作用(如越界访问,动态定向什么的),引用可以代替指针。 C++ 中一般都用引用就可以了 ... C 中没有引用,就使用指针 .... 举例如下: 1 使用指针传递参数时: void function (int *ptr) { 函数体;} 调用该函数时 main() { int p; function (&p); } 2 使用引用传递参数时: void function(int &ref) { 函数体;} 调用该函数时 main() { int p; function (p); } 由此可见,使用引用比使用指针传递参数函数调用时更简单,引用和指针功能大体相同,但是有空间分配时建议最好使用指针,因为在释放空间时,对指针只需要delete就行了,而引用是不能删除空间的,引用必须指向一个存在的对象。 指针和引用的差别 1. 非空的差别任何情况下都不能使用指向空值的引用.一个引用必须总是指向某个对象. 不存在的指向空值的引用这个事实意味着使用引用的代码效率比使用指针要高. 2. 合法性区别在使用引用之前不需要测试他的合法性.指针必须测试. 3. 可修改区别指针可以被重新赋值给另一个不同的对象.但是引用总是指向在初始化的时候被制定的对象,以后不能改变.但是指定的对象其内容可以改变. 应该使用指针的情况: 可能存在不指向任何对象的可能性需要在不同的时刻指向不同的对象(此时,你能够改变指针的指向) 应该使用引用的情况: 如果总是指向一个对象并且一旦指向一个对象后就不会改变指向,使用此时应使用引用。 要首先好好理解指针和引用的区别 指针与引用看上去完全不同(指针用操作符’*’和’->’,引用使用操作符’.’),但是它们似乎有相同的功能。指针与引用都是让你间接引用其他对象。你如何决定在什么时候使用指针,在什么时候使用引用呢? 首先,要认识到在任何情况下都不能用指向空值的引用。一个引用必须总是指向某些对象。因此如果你使用一个变量并让它指向一个对象,但是该变量在某些时候也可能不指向任何对象,这时你应该把变量声明为指针,因为这样你可以赋空值给该变量。相反,如果变量肯定指向一个对象,例如你的设计不允许变量为空,这时你就可以把变量声明为引用。[Page] “但是,请等一下”,你怀疑地问,“这样的代码会产生什么样的后果?” char *pc = 0; // 设置指针为空值 char& rc = *pc; // 让引用指向空值 这是非常有害的,毫无疑问。结果将是不确定的(编译器能产生一些输出,导致任何事情都有可能发生),应该躲开写出这样代码的人除非他们同意改正错误。如果你担心这样的

C 中的指针与引用详细解读

C++中的指针与引用详细解读 1、指针和引用的定义 在深入介绍之前我们首先来看一下指针和引用的定义、指针和引用的区别,然后分别针对指针和引用展开讨论,深入细节为何有这些差异。 指针的权威定义: In a declaration T D where D has the form*cv-qualifier-seqopt D1And the type of the identifier in the declaration T D1is“derived-declarator-type-list T”,then the type of the identifier of D is “derived-declarator-type-list cv-qualifier-seq pointer to T”.The cv-qualifiers apply to the pointer and not to the object pointer to. ——摘自《ANSI C++Standard》 注:可能有些读者并不明白cv-qualifier-seq CV-qualifiers(CV限定符) CV-qualifiers有三种:const-qualifier(const限定符)、Volatile-qualifier(volatile限定符)、以及const-volatile-qualifier(const-volatile限定符)。 const类对象的非静态、非mutable、以及非引用数据成员是const-qualified; volatile类对象的非静态、非引用数据成员是volatile-qualified; const-volatile类对象的非静态、非引用数据成员是const-volatile-qualified。 当CV-qualifiers用于限定数组类型时,实际上是数组成员被该CV-qualifiers限定,而非该数组类型。 复合类型并不因其成员被CV-qualifier限定而被该CV-qualifier限定,也就是说,即使复合类型的成员有CV-qualifier限定,该复合类型也不是CV-qualified对象。 引用的权威定义: In a declaration T D where D has the form&D1And the type of the identifier in the declaration T D1is“derived-declarator-type-list T”,then the type of the identifier of D is “derived-declarator-type-list cv-qualifier-seq reference to T”.Cv-qualified references are ill-formed except when the cv-qualifiers are introduced through the use of a typedef or a template type argument,in which case the cv-qualifiers are ignored. ——摘自《ANSI C++Standard》

引用和指针的区别

在c++函数中,形式参数用引用和用指针都可以起到在被调用函数中改变调用函数的变量的作用。什么时候用引用作参数?什么时候用指针作参数呢void function (int *ptr); void function(int &ref); 没有特定的规定。。学的久了,就会习惯什么时候用指针什么时候用引用了! 引用与指针有什么区别? 1) 引用必须被初始化,指针不必。 2) 引用初始化以后不能被改变,指针可以改变所指的对象。 3) 不存在指向空值的引用,但是存在指向空值的指针。 C++中尽量用引用。个人觉得所有的引用都可以用指针,但指针比引用容易出错。 引用当然更直观更直接,做参数时,如果在函数内不刻意要用指针的那些副作用(如越界访问,动态定向什么的),引用可以代替指针。 C++ 中一般都用引用就可以了 ... C 中没有引用,就使用指针 .... 举例如下: 1 使用指针传递参数时: void function (int *ptr) { 函数体;} 调用该函数时 main() { int p; function (&p); } 2 使用引用传递参数时: void function(int &ref) { 函数体;} 调用该函数时 main() { int p; function (p); } 由此可见,使用引用比使用指针传递参数函数调用时更简单,引用和指针功能大体相同,但是有空间分配时建议最好使用指针,因为在释放空间时, 对指针只需要delete就行了,而引用是不能删除空间的,引用必须指向一个存在的对象。 指针和引用的差别 1. 非空的差别任何情况下都不能使用指向空值的引用.一个引用必须总是指向某个对象. 不存在的指向空值的引用这个事实意味着使用引用的代码效率比使用指针要高. 2. 合法性区别在使用引用之前不需要测试他的合法性.指针必须测试. 3. 可修改区别指针可以被重新赋值给另一个不同的对象.但是引用总是指向在初始化的时候被制定的对象,以后不能改变.但是指定的对象其内容可以改变. 应该使用指针的情况: 可能存在不指向任何对象的可能性需要在不同的时刻指向不同的对象(此时,你能 够改变指针的指向) 应该使用引用的情况: 如果总是指向一个对象并且一旦指向一个对象后就不会改变指向,使用此时应使用 引用。 要首先好好理解指针和引用的区别 指针与引用看上去完全不同(指针用操作符’*’和’->’,引用使用操作符’.’),但是它们似乎有相同的功能。 指针与引用都是让你间接引用其他对象。你如何决定在什么时候使用指针,在什么时候使用引用呢? 首先,要认识到在任何情况下都不能用指向空值的引用。一个引用必须总是指向某些对象。因此如果你使用一个变量并让它指向一个对象, 但是该变量在某些时候也可能不指向任何对象,这时你应该把变量声明为指针,因为这样你可以赋空值给

C语言中指针、数组和引用例子实例

一、指针:内容是指示一个内存地址的变量;类型是指示编译器怎么解释指针内容指向地址中的内容,以及该内存区域有多大; 例子: [cpp] int i = 0; int * pi = &i; printf(“pi = %x \n”, pi); // 打印pi的内容: 0x2000 printf(“*pi= %d \n” , *pi); // 打印pi指向地址中的值: 5 printf(“&pi= %x \n”, &pi); // 打印pi的地址: 0x100 从汇编的角度来看,指针是这样的: int i = 0; 010E139E mov dword ptr [i],0 int * pi = &i; 010E13A5 lea eax,[i] 010E13A8 mov dword ptr [pi],eax 二、数组:是一个单一数据类型对象的集合。其中单个对象没有被命名,通过索引访问。 数组名和指针的区别:数组名的内涵在于其指代实体是一种数据结构,这种数据结构就是数组。数组名的外延在于其可以转换为指向其指代实体的指针,而且是一个指针常量。指向数组的指针则是另外一种变量类型,仅仅意味着数组的存放地址 注意:虽然数组名可以转换为指向其指代实体的指针,但是它只能被看作一个指针常量,不能被修改,如下:天骄无双:https://www.360docs.net/doc/ad3999055.html, [cpp] int intArray[10]; intArray++; // 错误 “指针和数组等价”说的是什么?索引操作相同,例如:p[2]; a[2]; 三、引用(reference)是一个对象的别名。用对象初始化引用后,对象的名字和引用都指向该对象; 引用是如何实现的?从汇编语言的角度来看,指针和引用是一样的: [cpp] int i = 0; 00E9139E mov dword ptr [i],0 int & ref = i; 00E913A5 lea eax,[i] 00E913A8 mov dword ptr [ref],eax int * pi = &i; 00E913AB lea eax,[i] 00E913AE mov dword ptr [pi],eax 指针和引用的区别(从C++使用角度来看): 不存在空引用 引用要初始化 引用初始化后,不能指向另一个对象 这是由编译阶段保证的。 备注:一个指向非常量的引用不能用字面值或者临时值初始化;但是一个指向常量的引用可以。天骄无双:https://www.360docs.net/doc/ad3999055.html,

C++中引用与指针的区别

C++中引用与指针的区别(详细介绍) C++中的引用与指针的区别 指向不同类型的指针的区别在于指针类型可以知道编译器解释某个特定地址(指针指向的地址)中的内存内容及大小,而void*指针则只表示一个内存地址,编译器不能通过该指针所指向对象的类型和大小,因此想要通过void*指针操作对象必须进行类型转化。 ★相同点: 1. 都是地址的概念; 指针指向一块内存,它的内容是所指内存的地址; 引用是某块内存的别名。 ★区别: 1. 指针是一个实体,而引用仅是个别名; 2. 引用使用时无需解引用(*),指针需要解引用; 3. 引用只能在定义时被初始化一次,之后不可变;指针可变; 引用“从一而终” ^_^ 4. 引用没有const,指针有const,const 的指针不可变; 5. 引用不能为空,指针可以为空; 6. “sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小; typeid(T)== typeid(T&)恒为真,sizeof(T)== sizeof(T&)恒为真,但是当引用作为类成员名称时,其占用空间与指针相同4个字节(没找到标准的规定)。 7. 指针和引用的自增(++)运算意义不一样; ★联系 1. 引用在语言内部用指针实现(如何实现?)。 2. 对一般应用而言,把引用理解为指针,不会犯严重语义错误。引用是操作受限了的指针(仅容许取内容操作)。 引用是C++中的概念,初学者容易把引用和指针混淆一起。一下程序中,n 是m 的一个引用(reference),m 是被引用物(referent)。 int m; int &n = m; n 相当于m 的别名(绰号),对n 的任何操作就是对m 的操作。例如有人名叫王小毛,他的绰号是“三毛”。说“三毛”怎么怎么的,其实就是对王小毛说三道四。所以n 既不是m 的拷贝,也不是指向m 的指针,其实n 就是m 它自己。 引用的一些规则如下: (1)引用被创建的同时必须被初始化(指针则可以在任何时候被初始化)。 (2)不能有NULL 引用,引用必须与合法的存储单元关联(指针则可以是NULL)。 (3)一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)。 以下示例程序中,k 被初始化为i 的引用。语句k = j 并不能将k 修改成为j 的引用,只是把k 的值改变成为6.由于k 是i 的引用,所以i 的值也变成了6. int i = 5; int j = 6; int &k = i; k = j;// k 和i 的值都变成了6; 上面的程序看起来象在玩文字游戏,没有体现出引用的价值。引用的主要功能是传递函数的参数和返回值。C++语言中,函数的参数和返回值的传递方式有三种:值传递、指针传

C++中引用传递和指针传递函数参数的详解

先来分析指针这个东东: 从概念上讲,指针本质上就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。 上面的图表示了程序运行时变量的值和地址,这时的内存长什么样子呢? 注意指针是一个变量,它当然有内存空间,里面存的就是一个地址,通过这个地址我们就能找到它所指向的对象。

说明:上图中两个字母p和n在最左边,代表什么?后面在介绍程序的编译过程中用到,先卖个官司。如果下面的写的东西你看不懂,没关系,往下看,我不相信你看完最后的编译原理的一点点知识,你仍然不懂! 再来分析引用这个东东: 而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量)。 上面的这段话,如果不理解,没关系,往下看。 在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的: 指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变)

说明:红线上面是另一个函数的占空间,该函数可以通过指针的方式修改n的值,或者修改自己的值,让自己指向其他的地址,不再指向n。但是不管怎样,它永远修改不了p的值。因为参数传递的方式是值传递。 注意:什么叫能修改p值?能修改p这个变量标识符对应的内存空间就叫做修改了p的值。 而在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

引用传递与指针传递区别

C++中引用传递与指针传递区别 在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的: 指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变) 而在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。 引用传递和指针传递是不同的,虽然它们都是在被调函数栈空间上的一个局部变量,但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数,如果改变被调函数中的指针地址,它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量,那就得使用指向指针的指针,或者指针引用。 为了进一步加深大家对指针和引用的区别,下面我从编译的角度来阐述它们之间的区别: 程序在编译时分别将指针和引用添加到符号表上,符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值,而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改,因此指针可以改变其指向的对象(指针变量中的值可以改),而引用对象则不能修改。 最后,总结一下指针和引用的相同点和不同点: ★相同点: ●都是地址的概念; 指针指向一块内存,它的内容是所指内存的地址;而引用则是某块内存的别名。 ★不同点: ●指针是一个实体,而引用仅是个别名; ●引用只能在定义时被初始化一次,之后不可变;指针可变;引用“从一而终”,指针可以“见异思迁”; ●引用没有const,指针有const,const的指针不可变;(具体指没有int& const a这种形式,而const int& a是有的,前者指引用本身即别名不可以改变,这是当然的,所以不需要这种形式,后者指引用所指的值不可以改变) ●引用不能为空,指针可以为空; ●“sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof 指针”得到的是指针本身的大小;typeid(T)== typeid(T&)恒为真,sizeof(T)==sizeof(T&)恒为真,但是当引用作为成员时,其占用空间与指针相同(没找到标准的规定) ●指针和引用的自增(++)运算意义不一样; ●引用是类型安全的,而指针不是,引用比指针多了类型检查 ★联系 1. 引用在语言内部用指针实现(如何实现?)。 2. 对一般应用而言,把引用理解为指针,不会犯严重语义错误。引用是操作受限了的

C语言程序设计练习题之 指针与引用

指针 一、单项选择题 (在每小题列出的四个备选项中只有一个是符合题目要求的。) 1.C++中,指针变量的值只能是 A.变量名B.变量的值C.变量的别名D.NULL或地址值 2.若变量已正确定义并且指针p已经指向变量x,则*&x相当于 A.x B.p C.&x D.&*p 3.若有int x,*p1=&x,*p2;要使p2也指向x,正确的赋值语句是 A.p2=p1;B.p2=&p1;C.p2=*p1;D.p2=**p1; 4.设int *p1,*p2,i=1;则p1=&i;p2=p1;表示 A.把i值赋给p2 B.p1指向p2 C.p2指向i D.p2指向p1 5.若有int *p1,*p2,m=5,n;下列进行赋值的语句中合理的是 A.p1=m; B.pl=&m; C.*p1=&m; D.&p2=n; 6.若有int i,j=2,*p=&i;则能完成i=j赋值功能的语句是 A.i=*p; B.i=**p; C.i=&j; D.*p=*&j; 7.在C++中,数组名是 A.一个数组元素B.数组的第一个元素 C.一个地址常量D.所有数组元素 8.若有定义:int a[5];则a数组中首元素的地址可以表示为 A.a B.a+1 C.&a D.&a[1] 9.设char s[10],*p=s;下列语句中错误的是 A.p=s+5;B.s=p+s;C.s[2]=p[4];D.*p=s[0]; 10.设int a[10],*p=a;数组元素a[4]的正确引用是 A.*(p+4) B.*p+4 C.p+4 D.a+4 11.设int x[]={1,2,3,4,5,6,7,8,9,10},*p=x;,则值为3的表达式是A.p+=2, *p++ B.p+=2, *++p C.p+=2, p++ D.p+=2, ++*p 12.设有int a [ ]={0,1,2,3,4,5,6,7,8,9},*p=a; ,且0≤i<10,则对数组元素地址的正确表示是 A.&(a+1) B.a++ C.&p D.&p[i] 13.若int a[3]={1,2,3},*p;则下列赋值语句中正确的是 A.p=&a;B.*p=a;C.*(a+1)=a;D.p=a+1 14.以下语句或语句组中,能正确进行字符串赋值的是 A.char *sp;*sp="right!";B.char s[10];s="right!"; C.char s[10];*s="right!";D.char *sp="right!";

C++指针转换为引用

C++实现两个数的转换 指针: #include voidmySwap(int *a,int *b); int main() { int a=16,b=48; cout<<"a="<

相关主题
相关文档
最新文档