c++ 参数传递方式有三种,分别为:传对象,传引用和传指针,那这三种传递方式之间到底有什么区别呢?
 
传对象:是将实参对象的值传递给形参对象,是单项传递,在函数中修改形参的值时,不会影响到原来实参的值
 
传引用:把实参对象名传给形参对象名,形参对象名就成为实参对象名的别名,实参和形参代表同一个对象,所以改变形参,就是改变实参对象的值.
 
传指针:将指向对象的指针作为函数的参数,形参是对象的指针,实参是对象的地址值, 通过改变形参的值来改变实参的地址指向,形参传递的就是实参本身,所以当在函数中改变形参的值时,改变的就是原来实参的值.
 
引用和指针有什么区别?
 引用和指针有形式之处,都会对内存地址上存在的变量进行修改,但它不占用新的地址,从未节省开销.

如何正确使用指针(指针作为输出型参数)与结构体指针作为函数参数
 


 
文章目录
 
如何正确使用指针(指针作为输出型参数)与结构体指针作为函数参数
指针作为输出型参数
指针作为输出型参数本质
结构体指针就是一普通指针变量
详细例子说明
  
 

 
指针作为输出型参数
 
指针作为输出型参数，通俗的理解，指针作为某一函数的实参，在函数内部发生改变后，外部的值也能跟着发生变化
类比外部的int a作为函数形参并能够传出来，要用指针形式，外部的指针作为函数形参并能够传出来，要使用指针的指针作为形参类型，其实它们的本质原理是一样的，都是传了变量的内存地址给函数
 
程序1:
void myMalloc(char *s) //在函数中分配内存,再返回 
{ 
	s=(char *) malloc(100); 
} 
void main() 
{ 
	char *p=NULL; 
	myMalloc(p); //这里的p实际还是NULL,p的值没有改变
	if(p) free(p); 
} 
程序2：
void myMalloc(char **s) //指针的指针，双重指针类型
{ 
   *s=(char *) malloc(100); 
 } 
void main()     
{ 
	char *p=NULL; 
	myMalloc(&p); //这里的p可以得到正确的值
	if(p) 
		free(p); 
} 
 
指针作为输出型参数本质
 
指针变量就是一普通变量，当定义了一个变量，操作系统会为其分配相应的内存单元，内存里面存放的都是多个0和1组成的二进制数。
函数参数传递都是值传递
左值和右值，变量做左值，指向的是变量的内存空间，变量做右值，含义为将变量内存中存放的值取出来
取地址符&，与解地址符 *
 
假设有一变量 char *a = null;
 假设有一函数 func(char *x) {x = ‘a’;}
 调用func(a)之后，a还是为null。
 
调用中间的处理过程：func 临时定义了一个变量 char *x，函数内部使用的是x，而不是直接使用a，然后做了x=a的动作。函数内部一直都是在对x进行操作，故不会改变到a的值。
 
将函数换成func(char **x) {*x=‘a’;}
 调用func(&a)之后，a的值为字符’a’。
 
调用中间的处理过程：func 临时定义了一个变量 char **xx，函数内部使用的是x，然后做了x=&a的动作，则x变量存放了a的内存地址，函数内部对x进行解地址，即将x变量对应的内存中的那一串0101组成的二进制拿出来，这一串0101组成的二进制就是a的内存地址，*x=‘a’ 即向该空间写值。
 
结构体指针就是一普通指针变量
 
结构体指针作为函数参数
 
void fb_open(struct framebuffer *fb)//指针
{
    ...
}

void main()
{
    struct framebuffer fb0;
    fb_open(&fb0);//取地址符&
    
	struct framebuffer* fb1;//需要给这个指针分配实体
	fb1 = (struct framebuffer*)malloc();
    fb_open(fb1);//这时就不用取地址符，fb1中的成员的值在fb_open中被改变会影响
}
 
详细例子说明
 
#include <stdio.h>
#include <stdlib.h>

struct test_t{
    int *p;
    
    int a;
    int b;
    int c;
    int d;
};

//函数外部使用malloc测试函数 (函数形参为结构体类型)
void func1(struct test_t * test)
{
    test->a += 1;
    printf("test->a = %d.\n", test->a); 
}

/* 以下为函数内部使用malloc测试函数 (函数形参为结构体类型) */
void func2(struct test_t * test)
{   
    test = (struct test_t *)malloc(sizeof(struct test_t));
    test->b = 1;
    printf("test->b = %d.\n", test->b);
}

//...func3...


void func4(struct test_t **test)
{
    *test = (struct test_t *)malloc(sizeof(struct test_t));
    (*test)->d = 1;
    printf("test->d = %d.\n", (*test)->d);
}


void func_p(struct test_t * test)
{
    test->p = (int *)malloc(sizeof(struct test_t));
}

int main(void)
{
    //使用案例1：函数外malloc
    struct test_t * t1;
    t1 = (struct test_t *)malloc(sizeof(struct test_t));
    t1->a = 1;
    func1(t1);//这样使用,t1->a的值就会改变，和func4(struct test_t **test)区分
    printf("test->a = %d.\n", t1->a);
    free(t1);
    
    
    //有时候需要在函数里面malloc,如下：
#if 0
    //使用案例2：错误使用，编译通过，运行触发段错误
    struct test_t *t2 = null;
    func2(t2);
    printf("test->b = %d.\n", t2->b);
    free(t2);
#endif

#if 1    
    //但是可以在结构体里声明一个指针成员，然后如下使用
    //(实际上原理和案例1是一样的，外部需要有实体，但是这里还提出来，是因为想说一下free的问题)
    //为结构体内部的指针分配内存还是经常遇到的，包含该指针的结构体也是malloc而来的，但是有时只记得free最外层的指针
    struct test_t * t0;
    t0 = (struct test_t *)malloc(sizeof(struct test_t));
    func_p(t0);
    printf("test->p = %p.\n", t0->p);
    free(t0->p);//不会触发段错误，注意free这个指针，还要注意先free这个指针，再free t0
    free(t0);
#endif
    
    
#if 0
    //使用案例3：
    struct test_t * t3;
    
    t3 = 返回值为struct test_t *的func3函数;
    ...
#endif     
    
    //使用案例4：(func4形参使用双重指针类型)
    struct test_t * t4;
    func4(&t4);
    printf("test->d = %d.\n", t1->d);
    free(t4);
    
    //个人常用的就上面几种,当然还有这里没列出来的使用方式
    
    /** 总结
     * >> 函数使用指针类型形参以提高效率     
     * (1)外部定义指针变量再malloc分配
     * (2)函数外部的指针在函数内部malloc后能得到分配的内存地址的两种方式：双重指针和返回值
     * 多多编程多多体会
     */
    return 0;
}


打印内容：
test->a = 2.
test->a = 2.
test->p = 0x81ed020.
test->d = 1.
test->d = 1.
 
附：在C语言中，使用结构体的时候 “->” 和 “." 的区别？
 
定义的结构体如果是指针，访问成员时就用->
如果定义的是结构体变量，访问成员时就用.
例如：
struct AAA {
    int a;
    char b;
};
struct AAA q; 访问成员就用：q.a;
struct AAA *p; 访问成员就用：p->a;

 
 
在c语言中实参和形参之间的数据传输是单向的“值传递”方式，也就是实参可以影响形参，而形参不能影响实参。指针变量作为参数也不例外，但是可以改变实参指针变量所指向的变量的值。
 
#include <stdio.h>
void swap1(int x,int y),swap2(int *px,int *py),swap3(int *px,int *py);
int main(void)
{
	int a=1,b=2;
	int *pa=&a,*pb=&b;
	swap1(a,b);
	printf("s1:a=%d,b=%d\n",a,b);

	a=1,b=2;
	swap2(pa,pb);
	printf("s2:a=%d,b=%d\n",a,b);

	a=1,b=2;
	swap3(pa,pb);
	printf("s3:a=%d,b=%d\n",a,b);
	
	return 0;
}
void swap1(int x,int y){
	int t;
	t=x;
	x=y;
	y=t;
}

void swap2(int *px,int *py){
	int t;
	t=*px;
	*px=*py;
	*py=t;
}

void swap3(int *px,int *py){
	int *pt;
	pt=px;
	px=py;
	py=pt;
}
 
结果：
 
 
第一个swap1函数运行结果是：x=2   y=1.但是第一个函数的形参是(int x,int y)，实参是(int a,int b)。因为实参可以影响形参，而形参不可以影响实参。所以a，b的值是不变的。如图：
 
             
 
第二个swap2函数由图可知，pa和px都是a的地址，pb和py都是b的地址。此函数改变*px,*py的值。因为*px和a在同一储存单元，*py和b在同一储存单元。以改变实参指针变量所指向的变量的值。所以如图*pa和*pb的值也改变了，最后输出结果也就改变了。
 
 
第三个swap3同样的道理，如上图直接改变了形参指针px和py的值，改变的只是地址，地址所对应的值没有改变，又因为形参是不会影响实参，所以pa和pb没有改变。所以a，b值没有改变。

文章摘自“微学苑”,微学苑主讲C、C++和Shell
 
Original URL: http://see.xidian.edu.cn/cpp/biancheng/view/50.html
 

 
 
指针在函数中的使用也是十分广泛的。某些情况下，将指针作为函数的参数或函数的返回值会给我们带来方便。而某些情况下，我们又不得不将指针作为函数的参数或函数的返回值。
 
 指针作为参数
 
我们在上一章我们已经了解向函数传递数组的实质是向函数传递数组首元素的地址。我们又知道数组名是一个指向数组首元素的指针常量。
所以我们认为，向函数传递数组是将指针作为参数的特殊形式。

 

 
由于指针可以直接操作内存中的数据，所以它可以用来修改实参。
这个功能和引用是类似的。

 

 
下面我们来看一段程序，了解指针作为参数时的上述两个特点：（程序8.6.1）

 
#include "iostream.h"

 
void arrayCopy(int *src,int *dest,int size);//复制数组元素

 
void display(const int *array,int size);//输出数组元素

 
int main()

 
{

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

 
   int b[7];

 
   arrayCopy(a,b,sizeof(a)/sizeof(int));//把数组a的元素依次复制到数组b中

 
   cout <<"The data of array a is:";

 
   display(a,sizeof(a)/sizeof(int));

 
   cout <<"The data of array b is:";

 
   display(b,sizeof(b)/sizeof(int));

 
   return 0;

 
}

 
void arrayCopy(int *src,int *dest,int size)

 
{

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

 
   {

 
      dest[i]=src[i];//修改了实参数组元素

 
   }

 
   cout <<size <<" data Copied." <<endl;

 
}

 
void display(const int *array,int size)//const用来保护指针指向的数据

 
{

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

 
   {

 
      cout <<array[i] <<" ";

 
   }

 
   cout <<endl;

 
}

 

 
运行结果：

 
7 data Copied.

 
The data of array a is:3 4 5 6 3 1 6

 
The data of array b is:3 4 5 6 3 1 6

 

 
根据arrayCopy函数，不难看出传递数组和传递指针是完全相同的。而通过指针的间接引用或数组操作，我们可以在函数内实现对实参的修改。这就是arrayCopy函数能够实现复制功能的原因。

 

 
不过，将指针作为函数参数的副作用仍然不容我们忽视。
指针和引用虽然都能够修改实参，但是指针却更加危险。
因为引用仅限于修改某一个确定的实参，而指针却可以指向内存中的任何一个数据，通过间接引用就能够在一个函数内修改函数外甚至系统中的数据了
。这样一来，函数的黑盒特性就被破坏了，系统也因此变得不再安全。对于程序员来说，将指针作为函数参数可能把函数内的问题引到函数外面去，使得调试程序变得非常困难。所以，我们要认识到使用指针的两面性，谨慎对待指针做函数参数。

 

 
为了避免指针作为函数参数导致数据被意外修改，我们可以使用const来保护指针指向的数据，如程序8.6.1中的display函数。

 
 指针作为返回值
 
和别的数据类型一样，指针也能够作为函数的一种返回值类型。我们把返回指针的函数称为指针函数。在某些情况下，函数返回指针可以给我们设计程序带来方便。而且此时通过间接引用，函数的返回值还可以作为左值。

 

 
下面我们来看一段程序，了解函数如何返回指针：（程序8.6.2）

 
#include "iostream.h"

 
int * max(int *array,int size);//返回值类型是int *，即整型指针

 
int main()

 
{

 
   int array[]={5,3,6,7,2,1,9,10};

 
   cout <<"The Max Number is " <<*max(array,sizeof(array)/sizeof(int)) <<endl;//间接引用返回的指针

 
   return 0;

 
}

 
int * max(int *array,int size)//寻找最大值

 
{

 
   int *max=array;

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

 
   {

 
      if (array[i]>*max)

 
      max=&array[i];//记录最大值的地址

 
   }

 
   return max;

 
}

 

 
运行结果：

 
The Max Number is 10

 

 
需要注意的是，返回的指针所指向的数据不能够是函数内声明的变量。
道理很简单，我们在第六章已经说明，一个函数一旦运行结束，在函数内声明的变量就会消失。就好像下课同学们都走了，教室里的某一个座位到底有没有坐着谁我们无法确定。所以指针函数必须返回一个函数结束运行后仍然有效的地址值。