c++:函数传指针(void * xx)、传引用(void & xx)和传指针的引用(void *& xx)

本文详细解析了C++中指针与引用的概念、区别及其在函数参数传递中的应用,对比了指针与引用的不同行为,并举例说明如何正确使用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1。函数的形参是指针类型void func(int * arg)
void func(int * arg)
{
*arg = 15;
}
main()
{
int * p;
*p =12;
func(p);
printf(“%d’,*p);
}
函数输出的内容应该是:15
当func函数为如下:
void func(int * arg)
{
arg = (int *)malloc(sizeof(int));
*arg = 15;
}
输出却是:12
因为函数传递的指针,实际上是对p的地址的拷贝,两个指针是不同的指针但是指的对象是一样的,所有在func函数内我们可以修改地址下的内容,修改地址值是没有意义的;
2、传引用 void func(int &arg)
引用即为一个对象的别名,程序把引用的它的初始值绑定,而不是拷贝;
void func(int &arg)
{
arg = 15;
}
main()
{
int p =12;
func(p);
printf(“%d’,*p,);
}
输出的应该是:15;
形参相当于是实参的“别名”,对形参的操作其实就是对实参的操作,在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈
中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。
3、传指针的引用 void func(int *&arg)
struct Node
{int date; Node *next;};
void CreateList(Node *&head) //引用参数是表头指针
{
s=new Node;
cin>>s->data;
while(s->data!=0)
{if(head==NULL)head=s;
else p->next=s;
p=s;
s=new Node;
cin>>s->data;}
p->next-NULL;
delete s;
return;
}
函数需要修改指针的内容,而形参是指针形式,所以形参需要是指针的引用或指针的指针

以下是我觉得关于指针和引用写得很不错的文章,大家可参照看一下,原文出处地址:http://xinklabi.iteye.com/blog/653643

从概念上讲。指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。

而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量)。

在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的:

指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变)

而在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

引用传递和指针传递是不同的,虽然它们都是在被调函数栈空间上的一个局部变量,但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数,如果改变被调函数中的指针地址,它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量,那就得使用指向指针的指针,或者指针引用。

为了进一步加深大家对指针和引用的区别,下面我从编译的角度来阐述它们之间的区别:

程序在编译时分别将指针和引用添加到符号表上,符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值,而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改,因此指针可以改变其指向的对象(指针变量中的值可以改),而引用对象则不能修改。

最后,总结一下指针和引用的相同点和不同点:

★相同点:

●都是地址的概念;

指针指向一块内存,它的内容是所指内存的地址;而引用则是某块内存的别名。

★不同点:

●指针是一个实体,而引用仅是个别名;

●引用只能在定义时被初始化一次,之后不可变;指针可变;引用“从一而终”,指针可以“见异思迁”;

●引用没有const,指针有const,const的指针不可变;(具体指没有int& const a这种形式,而const int& a是有 的, 前者指引用本身即别名不可以改变,这是当然的,所以不需要这种形式,后者指引用所指的值不可以改变)

●引用不能为空,指针可以为空;

●“sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof 指针”得到的是指针本身的大小;

●指针和引用的自增(++)运算意义不一样;

●引用是类型安全的,而指针不是 (引用比指针多了类型检查)

复制代码
一、引用的概念

引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似,只是用&代替了*。
例如: Point pt1(10,10);
Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义,pt1和pt2表示同一对象。
需要特别强调的是引用并不产生对象的副本,仅仅是对象的同义词。因此,当下面的语句执行后:
pt1.offset(2,2);
pt1和pt2都具有(12,12)的值。
引用必须在定义时马上被初始化,因为它必须是某个东西的同义词。你不能先定义一个引用后才
初始化它。例如下面语句是非法的:
Point &pt3;
pt3=pt1;
那么既然引用只是某个东西的同义词,它有什么用途呢?
下面讨论引用的两个主要用途:作为函数参数以及从函数中返回左值。

二、引用参数

1、传递可变参数
传统的c中,函数在调用时参数是通过值来传递的,这就是说函数的参数不具备返回值的能力。
所以在传统的c中,如果需要函数的参数具有返回值的能力,往往是通过指针来实现的。比如,实现
两整数变量值交换的c程序如下:
void swapint(int *a,int *b)
{
int temp;
temp=*a;
a=*b;
*b=temp;
}

使用引用机制后,以上程序的c++版本为:
void swapint(int &a,int &b)
{
int temp;
temp=a;
a=b;
b=temp;
}
调用该函数的c++方法为:swapint(x,y); c++自动把x,y的地址作为参数传递给swapint函数。

2、给函数传递大型对象
当大型对象被传递给函数时,使用引用参数可使参数传递效率得到提高,因为引用并不产生对象的
副本,也就是参数传递时,对象无须复制。下面的例子定义了一个有限整数集合的类:
const maxCard=100;
Class Set
{
int elems[maxCard]; // 集和中的元素,maxCard 表示集合中元素个数的最大值。
int card; // 集合中元素的个数。
public:
Set () {card=0;} //构造函数
friend Set operator * (Set ,Set ) ; //重载运算符号*,用于计算集合的交集 用对象作为传值参数
// friend Set operator * (Set & ,Set & ) 重载运算符号*,用于计算集合的交集 用对象的引用作为传值参数

}
先考虑集合交集的实现
Set operator *( Set Set1,Set Set2)
{
Set res;
for(int i=0;i

<think>嗯,用户问的是C++中两种不同的std::list声明方式的区别,具体是std::list<void*>&std::list<void*>。首先,我得确定用户的基础水平,可能对指针引用有基本了解,但可能不太清楚在STL容器中的应用区别。 首先,我需要回忆C++引用递的区别。引用是别名,递的是变量的地址,而值递会创建副本。在函数参数中使用引用可以避免拷贝,提高效率,尤其是当容器很大时。但如果是声明变量的话,比如声明一个std::list<void*>&类型的变量,这必须引用一个已存在的对象,而std::list<void*>则是直接创建一个对象。 然后,用户提供的引用中有提到关于比较器类型转换的内容,比如引用[1]中的=delete=default,可能用户在代码中遇到了拷贝或类型相关的问题,但当前问题更关注声明方式的不同。引用[3]提到了使用const char*string作为map的key,可能用户之前在处理容器时遇到过性能或正确性问题,所以现在想了解不同声明方式的影响。 接下来,我需要明确这两个声明的应用场景。例如,函数参数中的引用递的区别。比如,void func(std::list<void*>& lst)void func(std::list<void*> lst),前者操作原列表,后者操作副本。但如果是变量声明的话,比如std::list<void*> myList;std::list<void*>& myRef = myList;,后者必须初始化,且不能重新绑定。 可能用户在实际编码中遇到了关于引用对象生命周期的问题,比如悬空引用,或者想要优化性能而使用引用。需要提醒用户注意引用的初始化以及生命周期管理,避免引用失效的情况。 另外,用户提供的引用[3]中提到使用string替换const char*作为map的key,可能用户对容器中元素类型的选择比较敏感,所以现在想了解容器本身的声明方式对性能或正确性的影响。需要指出,声明为引用类型时,容器本身不会被复制,而直接声明对象会拥有独立的数据。 最后,用户可能需要了解何时该使用引用声明,何时该使用对象声明。比如在函数参数中递大对象时使用引用,避免拷贝开销;而在需要独立实例时直接声明对象。同时,注意const引用的使用场景,以确保数据不被意外修改。</think>### C++中`std::list<void*>&`与`std::list<void*>`声明方式的区别 在C++中,`std::list<void*>&``std::list<void*>`的声明方式有以下核心区别: --- #### **1. 类型本质** - **`std::list<void*>`** 表示一个完整的`std::list`对象,其元素类型为`void*`。声明时会直接分配内存并初始化一个链表实例。例如: ```cpp std::list<void*> myList; // 声明一个实际存在的链表对象 ``` - **`std::list<void*>&`** 表示对某个已存在的`std::list<void*>`对象的引用(别名)。它本身不存储数据,仅绑定到目标对象的内存地址。例如: ```cpp std::list<void*>& refList = myList; // 引用已存在的对象 ``` --- #### **2. 内存管理** - **`std::list<void*>`** 对象拥有独立的内存空间,生命周期由作用域或`new/delete`控制。例如: ```cpp void func() { std::list<void*> localList; // 栈上分配,函数结束时自动释放 } ``` - **`std::list<void*>&`** 引用本身不占用独立内存(仅保存地址),其生命周期依赖于被引用的对象。需确保被引用对象的有效性,避免悬垂引用: ```cpp std::list<void*>& getList() { std::list<void*> localList; return localList; // 错误!localList将在函数返回后销毁,导致悬垂引用 } ``` --- #### **3. 使用场景** - **`std::list<void*>`** 适用于需要独立实例的场景,如容器成员变量、局部容器或需控制生命周期的对象: ```cpp class MyClass { private: std::list<void*> data; // 独立成员变量 }; ``` - **`std::list<void*>&`** 适用于避免拷贝、共享数据的场景,如函数参数递或别名操作: ```cpp void modifyList(std::list<void*>& lst) { lst.push_back(nullptr); // 直接修改原链表 } ``` --- #### **4. 性能影响** - **`std::list<void*>`**递时会发生拷贝(如函数参),时间复杂度为$O(n)$,可能影响性能[^1]。 - **`std::list<void*>&`** 引用递无拷贝开销,适合大型链表的高效操作。 --- #### **5. 可变性控制** - 若需只读访问,可使用`const`修饰: ```cpp void readList(const std::list<void*>& lst) { // 只能读取,无法修改lst } ``` --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值