设为首页收藏本站

 找回密码
 立即注册

用新浪微博登录

只需一步,快速搞定

搜索
热搜: 活动 交友 discuz
查看: 2528|回复: 0

C中函数传递参数原理:值传递, 指针传递?

[复制链接]

1188

主题

1204

帖子

6125

积分

荣誉会员

北林Linux小组

积分
6125
QQ
发表于 2014-10-5 21:56:19 | 显示全部楼层 |阅读模式
这几天在学习C过程中,在使用指针作为函数参数传递的时候出现了问题,根本不知道从何得解:源代码如下:
    createNode(BinNode *tree,char *p)
    {
        tree = (BinNode *) malloc(sizeof(BinNode));
        tree->data = *p;
    }
该代码段的意图是通过一个函数创建一个二叉树的节点,然而在,调用该函数后,试图访问该节点结构体的成员时候,却发生了内存访问错误,到底问题出在哪儿呢?
一直不明白指针作为函数参数传值的机制,翻开林锐的《高质量C/C++编程指南》,找到了答案。
    [如果函数的参数是一个指针,不要指望用该指针去申请动态内存]
   
原来问题出在C编译器原理上:编译器总是要为函数的每个参数制作临时副本,指针参数tree的副本是 _tree,编译器使 _tree = tree。如果函数体内的程序修改了_tree的内容,就导致参数tree的内容作相应的修改。这就是指针可以用作输出参数的原因。
即上面的函数代码经过编译后成为:
    createNode(BinNode *tree,char *p)
    {
        BinNode *_tree;
        _tree = tree;
        _tree = (BinNode *) malloc(sizeof(BinNode));
        _tree->data = *p;
    }
如果没有
    _tree = (BinNode *) malloc(sizeof(BinNode));
这个语句,在函数体内修改了_tree的内容,将会导致参数tree的内容作相应的修改,因为它们指向相同的内存地址。而
    _tree = (BinNode *) malloc(sizeof(BinNode));
这个句,系统重新分配内存给_tree指针,_tree指针指向了系统分配的新地址,函数体内修改的只是_tree的内容,对原tree所指的地址的内容没有任何影响。因此,函数的参数是一个指针时,不要在函数体内部改变指针所指的地址,那样毫无作用,需要修改的只能是指针所指向的内容。即应当把指针当作常量。
如果非要使用函数指针来申请内存空间,那么需要使用指向指针的指针
    createNode(BinNode **tree,char *p)
    {
        *tree = (BinNode *) malloc(sizeof(BinNode));
    }
[/table]
使用二级指针就可以了。
ytc:更简单的方法是用 & 来引用:
    createNode(BinNode *&tree,char *p)
    {
        tree = (BinNode *) malloc(sizeof(BinNode));
    }
前一种方法把函数中的参数进行了“升级”,比如原来是值的,要升级成指针处理,而第二种方法,则是以“平级”的方式处理,原来参数是什么类型,那么在函数中处理的还是什么类型。再比如:
void add(int &a)
{   
    a += 3;
}
int main()
{
    int p = 3;
    add(p);
    printf("%d
",p);
    return 0;
}
在函数中还是以“整型”来处理,不需要升级成int*。
还有有另外的一种方案,通过函数返回值传递动态内存:
    BinNode *createNode()
    {
        BinNode *tree;
        tree = (BinNode *) malloc(sizeof(BinNode));
        return tree;
    }
这个倒还说得过去,因为函数返回的是一个地址的值,该地址就是申请的内存块首地址。但是,这个容易和另外的一个忠告相混绕
    [不要用return语句返回指向“栈内存”的指针,因为该内存在函数结束时自动消亡]
taylor:要正确的理解这句话,以前我的理解是不要返回在栈上分配的指针变量,这种理解是错误的。
正确的理解应该是:指针变量指向的内容在栈上是不行的,因为函数结束的时候,内容被销毁了。指针变量大部分时候都在栈上分配,但是里面的内容有的是在栈上分配的。例如:
    char *GetString(void)
    {
        char p[] = {1,2,3,4,5};
        return p; // 编译器将提出警告,因为函数结束的时候,数组里面的内容销毁了,p指向了一个随即的地址。如果将p改为在堆上分配就正确了。
    }
这里区分一下静态内存栈内存动态分配的内存(堆内存)的区别:
(1) 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在。例如全局变量,static变量。
(2) 在栈上创建。在执行函数时,函数内局部变量的存储单元都可以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。
(3) 从堆上分配,亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存,程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定,使用非常灵活,但问题也最多。
因此,试图返回一个栈上分配的内存将会引发未知错误
    char *GetString(void)
    {
        char p[] = "hello world";   
// 这是一个数组,在栈分配空间,用"
hello world
"作初始化。函数退出后,这个栈分配的空间将被释放。如果定义为char*p = "
hello world
"; p是一个指针,指针字符串常量"
hello world
",这个常量是存在常量区的,整个程序生命期内都有效,而返回的只是这个地址,而不是栈的地址,所以在主调函数中,是可以取到正常的内容
        return p; // 编译器将提出警告
    }
p是在栈上分配的内存,函数结束后将会自动释放,p指向的内存区域内容不是"hello world",而是未知的内容。
如果是返回静态存储的内存呢:
    char *GetString(void)
    {
        char *p = "hello world";  
        return p;
    }
[table=100%,#ffffff]

这里“hello world”是常量字符串,位于静态存储区,它在程序生命期内恒定不变。无论什么时候调用GetString,它返回的始终是同一个“只读”的内存块。


总结:无论是值传递还是指针传递,传递的都是实参的值的一份拷贝副本,
如果是基本数据,拷贝的是数据的值,如果是指针,拷贝的是实参的值(值是一个地址)。
如果想改变实参的值,变量必须是指针。因而也就有上面例子中说的二级指针问题,其实很好理解。


如果把一个变量彻底的分析:
一个变量在内存中有2个部分的内容:
1,变量的地址
2,变量的值
一:对于普通变量如:int a = 3;
a的地址为0x11,值为3
如果传递a
add(3)
int add(int x){
  x = x+1;

那么函数调用的时候,其实传递的是a的值3。
二:对于对象或者指针变量(其实对象就是一个引用或者指针),如:

void test(char * a)
{
    a = "abc";
}


int main(int argc, char* argv[])
{
    char *str = "123";
    test(str);
    printf("%s\n",str);
    return 0;
}
执行结果:123


而:

void test(char * &a)
{
    a = "abc";
}

int main(int argc, char* argv[])
{
    char *str = "123";
    test(str);

    printf("%s\n",str);
    return 0;
}
执行结果:abc
str的地址为0x11,其实也就是str的值为0x11,0x11地址里面的内容为“123”,str自身的内存为0x123,
参数拷贝的时候,其实是把str的值0x11拷贝一份给char*a,也就是a的值为0x11,但是a本身的地址为0x126,
其实拷贝的也是str的值,只不过str的值是一个地址而已,str的内容为"123"。注意区别与平常所说的取值,
例如:char *ch = “xx”;ch表示地址,*ch表示取值。平常说的ch地址不是我这里说的ch变量在内存中的地址,而是ch变量指向的地址,也就是ch变量在内存中的地址里面存放的值,这个值是一个地址。
因此所有的拷贝都是值拷贝,其实没有什么指针拷贝之类的,只不过值为指针而且,拷贝的是实参的值,而不是实参的地址。
其实以变量的属性来说,每个变量的地址在内存中都是唯一的,比如0x2000之类的,没有说变量的地址是可以拷贝的,因为每个变量的地址都是唯一的。
只有变量的值可以是重复的,可以拷贝的。但是值可以是地址。
所以函数参数传递,传递的都是实参变量的值。




"之所以产生所谓的引用传递,是因为所有对象变量的值只能是一个地址,不可能是一个基本的数据,例如4。所以传递对象就是传递一个地址,不可能说传递一个数值4之类的。  其实引用传递,就是传递的变量的值(这个值是一个地址)。"这句话只对java中的对象有效,如果是c或者c++中,参数是结构体,或者对象本身的时候,是不同的,
比如在c语言中,函数的参数是结构体的话,如果传过去是结构体,是不能改变结构体里面的内容的值的,拷贝的是实参的值,也就是另一个结构体。
如果要改变结构的值,必须要传结构体的指针才能够改变。
c++˙中如果传的不是对象指针,而是对象本身,那么也是不能够改变对象的内容的,这是为什么呢?
因为操作的时候是操作的实参对象的一个副本,通过这个副本是无法访问实参对象的地址内容的,因此修改也只是修改了这个副本的内容,实参对象并没有被修改,只有当传入的是实参对象的地址的时候,操作的就是这个地址的副本,然后通过这个地址的副本是能过访问到实参对象的。


参考程序

#include <stdio.h>
#include <stdlib.h>

//定义节点
typedef struct BiNode{
        char data;
        struct BiNode *lch;
        struct BiNode *rch;
}BiNode,*BiTree;

//先序拓展序列建立二叉树
void Create(BiTree &T)
{
        T =(BiNode*) malloc (sizeof(BiNode));

        scanf(" %c",&T->data);
        if(T->data=='#')
            T = NULL;
        if(T){
                printf("");
                Create(T->lch);
                Create(T->rch);
        }
}

//先序遍历 (递归)
void Preorder (BiTree T)
{                    
   if (T) {
      printf(" %c",T->data);             // 访问根结点

      Preorder(T->lch); // 遍历左子树
      Preorder(T->rch);// 遍历右子树
   }
}

//中序遍历 (递归)
void Inorder (BiTree T)
{
     if(T) {
       Inorder(T->lch);

       printf(" %c",T->data);

       Inorder(T->rch);   
       }
}

//后序遍历 (递归)
void Postorder (BiTree T)
{
     if(T) {
       Postorder(T->lch);
       Postorder(T->rch);

       printf(" %c",T->data);
     }
}

int main()
{
    //建树
    printf("The fuction Create() is called.\n");
    BiTree T;
    Create(T);

    //三种遍历递归算法
    printf("\n");   
    printf("The fuction Preorder() is called.\n");
    Preorder(T);

    printf("\n");
    printf("The fuction Inorder() is called.\n");
    Inorder(T);

    printf("\n");
    printf("The fuction Postorder() is called.\n");
    Postorder(T);


    printf("\n");
    return 0;

}
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|Archiver|手机版|小黑屋|北林linux用户组 ( 京ICP备14050379号-1|人工智能

GMT+8, 2019-9-19 01:38 , Processed in 0.161770 second(s), 27 queries .

Powered by 北林Linux用户组

© 2014-2019 YTC