指针使用小结 -- 指针传递与指针所指空间赋值
结合示例 总结一下 指针的各个概念及指针变量在函数中的传递与应用
int a = 3;
int* point =&a;
设内存分布如下
0x300000 a 3
0x500000 point 0x300000
指针变量（用于存储其他变量的空间地址）point （0x300000），指针变量的存储地址（指针变量自身的地址）&point
(0x500000)，指针的指向存储空间的值 *point
#include &stdio.h&
#include &malloc.h&
#include &stdlib.h&
typedef int* T
void swap(int* a, int* b);
int InitArray(int* arr, int a, int b, int c);
int InitTriplet(Triplet* T, int a, int b, int c);
int TestPointAssign(Triplet T, int a, int b, int c);
int main()
int m = 2, n = 4;
int Array[] = {1, 2, 3};
Triplet T_num = NULL;
swap(&m, &n);
printf(&m = %d, n = %d\n&, m, n);
//为已分配空间（指针指向/数组）赋值
InitArray(Array, 11, 12, 13);
printf(&A[0] = %d, A[1] = %d, A[2] = %d\n&, Array[0], Array[1], Array[2]);
//指针变量T_num的值（指向的地址）与自身地址
printf(&before test:T_num:%d, &T_num:%d\n&, T_num,
TestPointAssign(T_num, 111, 112, 113);
//指针变量T_num的值（指向的地址）与自身地址
printf(&after test:T_num:%d, &T_num:%d\n&, T_num,
//指针指针指向新地址之前的地址 （此处 NULL--0000）
//printf(&address before resign:%d\n&,T_num);
//使指针指向新地址，在新地址处为其分配所指定大小的存储空间
InitTriplet(&T_num, 1, 2, 3);
//T_num存储指针指向新地址之后的地址 （即连续3个存储空间的首地址）
printf(&after resign:T_num:%d, *T_num:%d, &T_num:%d\n&, T_num, *T_num, &T_num);
printf(&Init point:T_num[0] = %d, T_num[1] = %d, T_num[2] = %d\n&, T_num[0], T_num[1], T_num[2]);
void swap(int* a, int* b)
int c = *a;
int InitArray(int* arr, int a, int b, int c)
int InitTriplet(Triplet* T, int a, int b, int c)
*T = (int*)malloc(sizeof(int) * 3);
if ( !(*T) )
printf(&overflow&);
int TestPointAssign(Triplet T, int a, int b, int c)
T = (int*)malloc(sizeof(int) * 3);
printf(&overflow&);
printf(&In function 0~2: %d, %d, %d\n&, T[0], T[1], T[2]);
printf(&In function test address:%d\n&,T);
运行结果：
int* p_num = NULL; //定义指针变量 p_num, 并初始化 使其 指向NULL（0000地址）
即p_numm 为其指向的地址（0x000000）
*p_num 为 指向地址所储存值。 （0x000000 存储数据不可访问）
&p_num 为 指针变量p_num 自身所在的存储空间。 （假设此处为 0x300000 ）
p_num = (int*) malloc(sizeof(int) * 3);
p_num 指向一个新的地址存储空间 (假设为 0x500000)
*p_num 为 指向地址所储存值。 （0x500000 中存储的数据）
&p_num 为 指针变量p_num 自身所在的存储空间。 （为 0x300000 与上述一致，保持不变。即指针变量p_num自身的存储空间没变，只是其所指向的存储空间变了。 由原来指向的0x000000空间，变为由3个int构成的连续空间的首地址（低位地址）0x500000
int InitTriplet(Triplet* T,int a,int b, int c);
int TestPointAssign(Triplet T,int a,int b, int c);
前者传递的是指针变量T的指针（地址），后者传递的是指针变量
如同swap()函数的作用，如要在函数内 改变传递变量的值--将其带回，需要传递变量的地址，在所在地址处修改变量的值；而非传递一变量。后者 将 实参 T_num 的值传递函数，函数内部 T_num 将值赋值给另一存储空间（变量）T，修改的是变量T--test adress假设为 0x533245，而非变量T_num--须将T_num的地址传递到函数内部。
int InitArray(int* arr,int a,int b, int c);
int array[3] = {0};
int* point_t = NULL;
InitArray(array, 1, 2, 3);//ok -- arr为一数组名，有固定的存储空间。在空间地址内赋值即可
InitArray(point_t, 1, 2, 3);//error -- point_t为一指针，需为其所指向地址分配空间，才可赋值
指针与引用
C++中 可以用 引用 来实现下函数
int InitTriplet(Triplet* T, int a, int b, int c)
//指针传递
*T = (int*)malloc(sizeof(int) * 3);
if ( !(*T) )
printf(&overflow&);
InitTriplet(&T, 1, 2, 3);
int InitTriplet(Triplet& T, int a, int b, int c)
T = (int*)malloc(sizeof(int) * 3);
printf(&overflow&);
InitTriplet(T, 1, 2,3);Objective-C中的指针很容易和有趣的学习。更容易地执行一些语言的编程任务的指针，动态内存分配，其他的任务，如不能执行，而无需使用指针。因此，它成为必要学习指针成为一个完美的Objective-C程序员。让我们开始简单轻松的学习步骤。
如大家了解，每一个变量是一个内存位置和每一个存储单元都有其定义的地址，可以使用符号（＆）的运算符，它表示内存中的地址访问。考虑下面的例子，这将打印地址定义的变量：
#import &Foundation/Foundation.h&
int main ()
char var2[10];
NSLog(@&Address of var1 variable: %x
NSLog(@&Address of var2 variable: %x
上面的代码编译和执行时，它产生的结果如下的内容：
03:18:45.727 demo[17552] Address of var1 variable: 1c0843fc
03:18:45.728 demo[17552] Address of var2 variable: 1c0843f0
所以，明白了什么是内存地址，以及如何访问它，这些是基本的概念。现在，让我们看到了什么是一个指针。
什么是指针?
指针是一个变量，其值是另一个变量，即直接地址的内存位置的地址。像任何变量或常量，在使用之前必须声明指针，可以用它来存储任何变量地址。一个指针变量声明的一般形式是：
type *var-name;
在这里，type 为指针的基本类型，它必须是一个有效的Objective-C的数据类型和 var-name 是变量的指针。用来声明指针的是一个星号（*）。然而，在这个声明中的星号是被用来作为一个指针来指定一个变量。以下是有效的指针声明：
/* yiibaier to an integer */
double *dp;
/* yiibaier to a double */
/* yiibaier to a float */
/* yiibaier to a character */
所有的指针的值的实际数据类型，无论是整数，浮点数，字符，否则，是一样的，很长的十六进制数字，表示一个内存地址。不同数据类型的指针之间的唯一区别是变量或常量的指针指向的数据类型。
如何使用指针？
有一些重要的操作，我们将非常频繁地与指针的帮助。 （a）我们定义一个指针变量，（b）分配一个指针变量的地址，（c）最后访问提供的地址指针变量的值。这是通过使用一元运算符*返回值的变量，其操作数位于指定的地址。下面的例子使用这些操作：
#import &Foundation/Foundation.h&
int main ()
/* actual variable declaration */
/* yiibaier variable declaration */
ip = &var;
/* store address of var in yiibaier variable*/
NSLog(@&Address of var variable: %x
/* address stored in yiibaier variable */
NSLog(@&Address stored in ip variable: %x
/* access the value using the yiibaier */
NSLog(@&Value of *ip variable: %d
上面的代码编译和执行时，它产生的结果如下的东西：
03:20:21.873 demo[24179] Address of var variable: 337ed41c
03:20:21.873 demo[24179] Address stored in ip variable: 337ed41c
03:20:21.874 demo[24179] Value of *ip variable: 20
Objective-C 的空指针
它始终是一个很好的做法，一个指针变量分配一个NULL值的情况下，没有确切的地址被分配。这样做是在当时的变量声明。被指定为NULL 指针，被称为一个空指针。
NULL指针是一个常数与几个标准库中定义的一个零值。考虑下面的程序：
#import &Foundation/Foundation.h&
int main ()
*ptr = NULL;
NSLog(@&The value of ptr is : %x
上面的代码编译和执行时，它会产生以下结果：
03:21:19.447 demo[28027] The value of ptr is : 0
大部分的作业系统，程序不允许被保留，因为该内存由操作系统来访问内存地址0处。然而，存储器地址0具有特殊的意义，它的信号，指针不指向一个可访问的存储器位置。但是，按照惯例，如果一个指针包含空值（零），它被假定为指向什么。
要检查空指针，可以使用一个if语句如下：
/* succeeds if p is not null */
/* succeeds if p is null */
Objective-C语言指针的详细介绍：
指针有很多，但简单的概念，他们在Objective-C编程是非常重要的。有以下几个重要的指针概念，这应该是一个Objective-C语言程序员清楚：
有四种算术运算符，可以用在指针中: &++, --, +, -
可以定义数组指针持有数值。
Objective-C中可以让一个指针指向指针。
引用或按地址传递参数的功能，既可以传递的参数调用函数被调用函数改变。
Objective-C中允许一个函数返回一个指向局部变量，以及静态变量和动态分配的内存。
易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。
上一篇：下一篇：
加QQ群啦，易百教程官方技术学习群
注意：建议每个人选自己的技术方向加群，同一个QQ最多限加3个群。
Java技术群：
（人数：2000，等级：LV5，免费：否）
MySQL/SQL群：
（人数：2000，等级：LV5，免费：否）
大数据开发群：
（人数：2000，等级：LV5，免费：否）
Python技术群：
（人数：2000，等级：LV5，免费：否）
人工智能深度学习：
（人数：2000，等级：LV5，免费：否）
测试工程师(新群)：
（人数：1000，等级：LV1，免费：是）
前端技术群(新群)：
（人数：1000，等级：LV1，免费：是）
C/C++技术(新群)：
（人数：1000，等级：LV1，免费：是）
Node.js技术(新群)：
（人数：1000，等级：LV1，免费：是）
PostgreSQL数据库（新群）：
（人数：1000，等级：LV1，免费：否）
Linux技术：
（人数：2000，等级：LV5，免费：否）
PHP开发者：
（人数：2000，等级：LV5，免费：是）
Oracle数据库：
（人数：2000，等级：LV5，免费：是）
C#/ASP.Net开发者：
（人数：2000，等级：LV5，免费：是）
数据分析师：
（人数：1000，等级：LV1，免费：是）R语言，Matlab语言等技术c++中,什么时候用 A和什么时候用A a=new A;_百度知道
c++中,什么时候用 A和什么时候用A a=new A;
c++中,什么时候用 A和什么时候用A a=new A;请说说A和A a=new A;的区别,在什么情况下用A在什么情况下用A a=new A;最好能给个实例,COPY的就不要了.
我有更好的答案
new是在堆上分配内存,它需要用delete释放,否则会造成内存泄漏(使用的内存没有即时释放,造成内存的浪费)而A a在右大括号执行后,会自动释放内存如int main(){A//定义了一个a对象A *p=new A;//在堆上定义了一个对象,它的指针保存在p里,注意,堆上定义的对象没有名字,必须用指针保存return 0;}//a到这里的时候,它占用的内存就会被回收 而p,除非调用 否则内存永远不会被回收,指针p丢弃后,那块内存没被释放,无法被再次使用,造成内存浪费
采纳率：32%
下面给你详细介绍一下动态分配内存new关见字的使用方法，希望看了之后你能全现了解什么时候可以使用new以及怎样使用new，以下内容全面，简单易懂，是完全出自本人的学习总结，绝非复制。动态分配内存new关见字1． 全局对象和局部对象的生命期都是严格定义的，程序员不能以任何方式改变他们的生命期。但是有时候需要创建一些生命期能被程序员控制的对象，他的分配和释放可以根据程序运行中的操作来决定。这时就需要使用new操作符了。2． 动态分配内存，将从堆中分配内存，动态分配的存储区是在运行时确定的，动态分配的存储区可以随着需求而自动扩大．3． 局部变量一般存储在堆栈中，堆栈是先进后出的存储结构，而堆却不是．4． 在C++中使用new动态分配内存，delete释放以前new分配的内存．5． 使用new运算符系统将从空闲存储区中为对象分配内存，并返回一个指向该对象的指针即该对象的地址。new运算符的特点是：用new运算符分配的对象没有名字，对该对象的操作都要通过指针间接地完成操作。例如new int，就是从空闲存储区分配了一个int型对象，但没法对这个对象进行操作，只是从存储区分配了这么一个空间。语句int *p=new int表示从空闲存储区分配一个int对象并把这个对象的地址赋给p，现在p就是用new分配的int对象的地址，而*p就是那里的值。语句int*p=&i;和int *p=new int都是将int变量的地址赋给了指针，但不同的是前句可以用名称i和*p来访问该int型变量，而后句则只能用*p来访问该变量，也就是说p指向的内存没有名称。6． 动态创建数组：int *p=new int [11]；创建动态数组时必须有[]方括号，且里面要有创建的维数，但该数组的第一维可以是一个复杂的表达式。访问地址中的内容的方法为*p访问数组中的第一个元素,p[1]该问第二个元素，以此类推。创建二组数组的例子：int (*p)[102]=new int [4][102]。7． 动态创建对象的初始化：int *p=new int(102)该语句表明由p指向的新创建你对象被初始化为102。动态创建对象的初始化方式为在类型名后面用一对括号来被始化。8． 动态创建对象的默认初始化：方式为在类型名后面跟一对空的圆括号初始化，
int *p=new int (); int *ps=new string(); cls *pc=new cls();第一条语句把对象的值初始化为0，第二条语句对于提供了默认构造函数的string类，不论程序是要明确的不初始化，还是要求进行值初始化都会调用默认构造函数初始化该对象。而对于内置类型或没有默认构造函数的类型，则采用不同的初始化方式就会有显著不同的差别。例如：int *p= int *p=new int();第一条语句没有被初始化，而第二条被初始化为0。9． 用new动态创建的数组不能被初始化，不能创建初始化值集。10．耗尽内存：如果程序用完了所有可用的内存，new表达式就有可能失败。如果new表达式无法获得要需要的内存空间，系统将会抛出名为bad_alloc异常。11．可以在一个函数内使用new运算符分配内存，而在另一个函数中使用delete释放内存空间．delete只能用于释放前次使用new分配的空间，不要使用delete来释放不是new分配的内存，不要使用delete释放相同的内存两次，应使用delete []来释放动态数组，例如：int *p=new int [10];delete []删除数组必须要有[]方括号。delete不一定要用于new的指针，例如int *p= int *x=p;将是合法的．如果指针的值为0，则在其上作delete操作是合法的，但没有任务意义。12．悬垂指针：执行delete p后只是把p所指向的地址的内容给释放掉了，并没有删掉指针p本身，还可以将p重新指向到另一个新的内存块，因此p还指向原来他指向的对象的地址，然而p所指向的内容却已经被释放了，因此p不再有效而变得没有定义了。这样的指针称为悬垂指针。悬垂指针往往导致程序错误而且很难检测出来。13．静态联编：如果通过声明来创建数组，则在程序被编译时为他分配内存空间，不管程序是否使用数组，数组都在那里，占用了内存。在编译时给数组分配内存被称为静态联编。意味着数组是在编译时加入到程序中的。但使用new时，如果在运行阶段需要数组，则创建他，如果不需要，则不创建，还可以在程序运行时选择数组的长度，这被称为动态联编。意味着数组是在程序运行时创建的，这种数组叫做动态数组，使用静态联编时必须在编写程序的时候指定数组的长度，使用动态联编时，程序将在运行时确定数组的长度。14．const常量对象的动态分配和回收：与其他常量一样，动态创建的const对象必须在创建时初始化，并且一经初始化，其值不能再修改。例如：const int *p= new const int(111)；删除方法为：delete p；尽管程序员不能修改const对象的值，但可以撤消对象本身。15．注意：不能在空闲存储区上创建内置类型元素(除类数组string外)的const数组。因为我们不能初始化用new创建的内置类型数组的元素。如const int *p=new const int [11]；将是错误的。16．注意：如果用new分配了资源，而没有用delete释放该资源的话，那么用new分配的资源将一指被占用。17．常见错误：如果对某个指针动态分配了内存，又把另一个变量的地址付给这个指针，这时这个指针就指向了一个静态地址，而不是原先的动态地址。如果再用delete删掉这个指针时就会出错，因为这时这个指针是指向静态地址的，不能用delete删除一个指向静态地址的指针。比如int *p =new int(1)，这时指针p指向一个动态内存可以对他进行delete删除，但如果再执行语句int a=2; p=&a;这时就改变了指针指向的内容，使原先指向的动态内存地址变成了指向现在的静态内存地址，如果这时对指针p进行delete操作就会出错，因为你在对一个静态指针静行删除，而delete只能删除动态指针。例：动态分配对象newclass hyong{public:int a,b,c;
hyong (){a=b=c=0;}
hyong(int i){a=b=c=i;}
~hyong(){cout&&&xigou&&&&\n&;}
};int main(){ hyong *p=
hyong *p1=new hyong(); cout&&p-&a&&p1-&a&&&\n&; //输出两个0，都调用默认构造函数初始化指针。
int *p3=new int();
int *p4=new int(1); //new分配内存的初始化方式。对于类置类型来说p2没有被初始化得到的是一个随机值，p3被初始化为0，p4被初始化为1。
cout&&*p2&&&\n&&&*p3&&&\n&&&*p4&&&\n&;
//输出一个随机值，一个0，一个1
delete p4;
cout&&*p4&&&\n&; //p4现在是悬垂指针，delete只是释放掉了指针p4所指向地址的内容，但指针p4仍然指向原来的地址，但没有内容，指针p4仍然可以再指向其他地址。
p4=&i; cout&&*p4&&&\n&; //可以对悬垂指针p4重新赋地址。
const int *p5= const int *p6=new int(4)cout&&*p5&&*p6&&&\n&;//输出一个随机值和4，const常量必须在声明时初始化。
int *p7=new int[2];
p7[0]=5;p7[1]=6;
cout&&p7[0]&&p7[1]&&&\n&;//定义动态数组,动态数组不能在声明时初始化。
//const int *p8=new int[2];
//错误，因为动态数组不能在声明时初始化，而const又必须要求在声明时初始化，发生冲突，出错。
delete p1;
//delete p,p1;
//注意，如果使用该语句将则只调用一次析构函数。
delete p2,p3,p4,p5,p6;
delete [] p7;
//int *p8=new int(9); int a=8;
p8=&a; delete p8;
//错误，现在的指针p8重新指向了一个静态的地址，用delete删掉一个静态地址将发生错误。
当然是根据用户的需求和设计来决定
A为一个类，当在同一个类中用A a，如果在不同的类中用new A
其他2条回答
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。 上传我的文档
 下载
 收藏
该文档贡献者很忙，什么也没留下。
 下载此文档
正在努力加载中...
04章 函数与C程序结构
下载积分：10
内容提示：04章 函数与C程序结构
文档格式：PPT|
浏览次数：0|
上传日期： 11:41:15|
文档星级：
全文阅读已结束，如果下载本文需要使用
 10 积分
下载此文档
该用户还上传了这些文档
04章 函数与C程序结构
关注微信公众号关于&c什么时候是取地址什么时候是引用_百度知道
关于&c什么时候是取地址什么时候是引用
main函数中的 &c不是一个地址吗。为什么可以地址传递给一个指针呢。为什么不是地址传递给指针的地址
例如有时 int *a； int c=10;
然后要给指针a声明地址，就 a=&c;
但是在传递函数值的时候
却用 *a来接收一个地址。。
void Add(int
我有更好的答案
*什么时候是“取内容”，什么时候是指针，搞清楚了，&也就清楚了。简单说在实参前它是取地址，在形参前它是引用的记号！也可以这么区分，跟在类型说明衔后是引用记号，位居实参变量前是取地址。——熟能生巧！如果碰到代码还要这么琢磨它表示什么，那实际上什么都没有弄懂……
。。。题目打错了。。请回答我给的问题描述中的问题。。抱歉！
指针的定义是“存放地址的变量”，为什么不能把地址传给指针？“int *a； int c=10;
然后要给指针a声明地址，就 a=&c;”中的a=&c;不是“给指针a声明地址”而是“给指针a赋值为变量c的地址“。void Add(int
*a ,int b)中的“int
*a”不是用*a接收地址，这里*是int的，不是a的，是声明了一个int *型指针a，*是为了表示a是一个指针的记号，没有其他意义；所以int
*a是用一个int *型指针a接收地址！看来你对*的用法还比较糊涂！
谢谢，之前搞了一下午，终于弄明白了！主要是写成int* a就比较不会产生误解，谢了
采纳率：75%
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。}