1为什么使用指针

假如我们定义了 char a=’A’ ，当需要使用 ‘A’ 时，除了直接调用变量 a ，还可以定义char *p=&a ，调用 a 的地址，即指向 a 的指针 p ，变量 a（ char 类型）只占了一个字节,指针本身的大小由可寻址的字长来决定，指针 p 占用 4 个字节。

但如果要引用的是占用内存空间比较大东西，用指针也还是 4 个字节即可。

• 使用指针型变量在很多时候占用更小的内存空间。
  , ]) B% @; w1 A5 |8 `/ b

变量为了表示数据，指针可以更好的传递数据，举个例子：

第一节课是 1 班语文， 2 班数学，第二节课颠倒过来， 1 班要上数学， 2 班要上语文，那么第一节课下课后需要怎样作调整呢？方案一：课间 1 班学生全都去 2 班， 2 班学生全都来 1 班，当然，走的时候要携带上书本、笔纸、零食……场面一片狼藉；方案二：两位老师课间互换教室。

显然，方案二更好一些，方案二类似使用指针传递地址，方案一将内存中的内容重新“复制”了一份，效率比较低。

• 在数据传递时，如果数据块较大，可以使用指针传递地址而不是实际数据，即提高传输速度，又节省大量内存。
  - {  l; a! D; R. N) a: Z

一个数据缓冲区 char buf[100] ，如果其中 buf[0,3] 为命令号, buf[4,5] 为类型, buf[6~10] 为该类型的数值，类型为 int ，使用如下语句进行赋值：

*(short*)&buf[0]=DataId;
*(short*)&buf[4]=DataType;
*(int*)&buf[6]=DataValue;
; O, [) A* K& W! _/ A

• 数据转换，利用指针的灵活的类型转换，可以用来做数据类型转换，比较常用于通讯缓冲区的填充。

• 指针的机制比较简单，其功能可以被集中重新实现成更抽象化的引用数据形式

• 函数指针，形如: #define PMYFUN (void*)(int,int) ，可以用在大量分支处理的实例当中，如某通讯根据不同的命令号执行不同类型的命令，则可以建立一个函数指针数组，进行散转。

• 在数据结构中，链表、树、图等大量的应用都离不开指针。

  
  

2 指针是什么？

操作系统将硬件和软件结合起来，给程序员提供的一种对内存使用的抽象，这种抽象机制使得程序使用的是虚拟存储器,而不是直接操作和使用真实存在的物理存储器。所有的虚拟地址形成的集合就是虚拟地址空间。

内存是一个很大的线性的字节数组，每个字节固定由 8 个二进制位组成，每个字节都有唯一的编号，如下图，这是一个 4G 的内存，他一共有 4x1024x1024x1024 = 4294967296 个字节，那么它的地址范围就是 0 ~ 4294967296 ，十六进制表示就是 0x00000000～0xffffffff ，当程序使用的数据载入内存时，都有自己唯一的一个编号，这个编号就是这个数据的地址。指针就是这样形成的。

1#include <stdio.h>
( C" e7 j, M5 W# [
0 f# f+ Q) S! I% s& Lint main(void)
: b1 E& Q' P. n( T9 ^; ~{
    char ch = 'a';
    int  num = 97;
    printf("ch 的地址:%p\n",&ch);   
6 r. U1 R/ m1 p6 c( M    //ch 的地址:00BEFDF7
$ w) q8 u4 ?! X4 k    printf("num的地址:%p\n",&num);  
    //num的地址:00BEFDF8
( e8 f- D2 Z8 G3 C    return 0;
}
5 Y$ k7 E. y) l

指针不仅可以表示变量的地址，还可以存储各种类型数据的地址，指针变量是用来保存这些地址的变量，与数组类似，依据地址存放的数据类型，指针也分为 int 指针类型，  double 指针类型， char 指针类型等等。

综上，指针的实质就是数据在内存中的地址，而指针变量是用来保存这些地址的变量。

指针变量 和 指向关系

用来保存 指针 的变量，就是指针变量。如果指针变量p保存了变量 num的地址，则就说：p指向了变量num，也可以说p指向了num所在的内存块，指针变量pp指向了p所在的内存块，以下面为例：

#include <stdio.h>

7 @7 m/ i9 M5 t+ K8 {int main(void)
) N: f( W7 X/ S" M1 c{
. L8 n. {3 B& Q0 R  int num = 97;
  char ch = 'a';

2 B. t% I# |2 z  int *p = & num;
  int **pp = &p;
% P' I3 C- I  h  char *p1 = & ch;
! Q' B& o& S. V* e1 f
) l/ Y# T1 O" c3 F4 G( F" l  printf("num 的地址:%p\n",&num);   
  printf("指针p的值:%p\n",p);   
  printf("指针p的地址:%p\n",&p);  
  printf("指针pp的值:%p\n",pp);
  printf("ch 的地址:%p\n",&ch);  
* K8 h2 P1 T% a
  return 0;
}
运行结果

• int型的num值为97占4个字节，内存地址为:0113F924，char 型的ch('a')值为97占1个字节，内存地址为:0113F91B。
  

int型占4个字节

char型占1个字节

• num的地址为：0113F924，num的值为 97 ，指针 p 指向 num 的内存块，指针 p 地址为：0113F90C，p的内存保存的值就是num的地址0113F924。
  

0x0113F90C存储的内容为地址0113F924

• 指针变量 pp 指向 指针 p，指针 pp 内存值为 指针 p 的地址：0113F90C，形成了只想指针的指针。
  / j1 X5 G7 \( K! X8 |1 x1 k

指针pp为指向指针p的指针定义指针变量

C语言中，定义变量时，在变量名 前 写一个 * 星号，这个变量就变成了对应变量类型的指针变量。必要时要加( ) 来避免优先级的问题。

引申：C语言中，定义变量时，在定义的最前面写上typedef ，那么这个变量名就成了一种类型，即这个类型的同义词。

int a ; //int类型变量 a
' q4 e! N4 l' S3 R( zint *a ; //int* 变量a
int arr[3]; //arr是包含3个int元素的数组
2 C2 H: e$ g2 ~6 s5 [8 z. A4 ?int (* arr )[3]; //arr是一个指向包含3个int元素的数组的指针变量
+ }( l8 L4 G9 s& f7 h
int* p_int; //指向int类型变量的指针
3 c. Q1 B6 Q5 m6 Qdouble* p_double; //指向idouble类型变量的指针
7 N* ?  ^2 k& S/ Y$ Tstruct Student *p_struct; //结构体类型的指针
int(*p_func)(int,int); //指向返回类型为int，有2个int形参的函数的指针
* M/ @, c) G$ q% e- pint(*p_arr)[3]; //指向含有3个int元素的数组的指针
int** p_pointer; //指向 一个整形变量指针的指针
取地址

既然有了指针变量，那就得让他保存其它变量的地址，使用& 运算符取得一个变量的地址。

int add(int a , int b)
{
    return a + b;
}

int main(void)
/ c) r; O  p8 K: Q" f6 A{
    int num = 97;
    float score = 10.00F;
8 l" [% U% W+ T/ [- H2 ~    int arr[3] = {1,2,3};

# g4 y. R7 r; h0 m+ R) Y$ U9 q    int* p_num = &num;
    float* p_score = &score;
, r+ R( b; v* S/ u2 M4 u& {    int (*p_arr)[3] = &arr;           
: a% J  q# \& c6 w: Z; Q    int (*fp_add)(int ,int )  = add;  //p_add是指向函数add的函数指针
    return 0;
}
. ^; p; m  ]4 N' Y8 ]# c

特殊的情况，他们并不一定需要使用&取地址：

• 数组名的值就是这个数组的第一个元素的地址。
• 函数名的值就是这个函数的地址。
• 字符串字面值常量作为右值时，就是这个字符串对应的字符数组的名称,也就是这个字符串在内存中的地址。
  

int add(int a , int b){
    return a + b;
}
+ N- [  q  \" y+ a# P- j' n8 Gint main(void)
6 M5 y2 Y9 [( R7 D: B- H7 w{
, w7 l3 w3 s* D! f" Z    int arr[3] = {1,2,3};
3 P9 c8 D+ d1 c9 g$ u* Y! y    int* p_first = arr;
# o) i) Z3 k7 G6 L1 Y6 d3 c1 [    int (*fp_add)(int ,int )  =  add;
& O# V1 B  |  J2 T6 H    const char* msg = "Hello world";
- N3 A6 }0 R. Q! p    return 0;
}
解地址

对一个指针解地址，就可以取到这个内存数据，解地址 的写法，就是在指针的前面加一个 * 号。

解指针的实质是：从指针指向的内存块中取出这个内存数据。

int main(void)
{
* O! \4 A- P% n    int age = 19;
    int*p_age = &age;
4 `$ P! F  q  ?, ~3 o) q2 \    *p_age  = 20;  //通过指针修改指向的内存数据
) M, d+ W0 c3 u( z) B5 T. W5 `
    printf("age = %d",*p_age);   //通过指针读取指向的内存数据
    printf("age = %d",age);

    return 0;
' k- H, x( ]  G! z9 _0 p}
空指针

空指针在概念上不同于未初始化的指针。空指针可以确保不指向任何对象或函数；而未初始化的指针则可能指向任何地方。空指针不是野指针。

在C语言中，我们让指针变量赋值为NULL表示一个空指针，而C语言中，NULL实质是 ((void*)0) ，  在C++中，NULL实质是0。

#ifdef __cplusplus
9 q& N1 r' @  T8 b& `" l     #define NULL    0
#else   
; u9 w/ m% ?8 x7 j     #define NULL    ((void *)0)
#endif
void*类型指针

void是一种特殊的指针类型，可以用来存放任意对象的地址。一个void指针存放着一个地址，这一点和其他指针类似。不同的是，我们对它到底储存的是什么对象的地址并不了解。

double a=2.3;
: K* ]% x( l3 D& yint b=5;
void *p=&a;
/ d# H2 J3 |& ?: q( Xcout<<p<<endl;   //输出了a的地址
) x; N0 o( E0 w" G, D! @
p=&b;
cout<<p<<endl;   //输出了b的地址
: M2 i) {" g  t5 @+ E7 w
//cout<<*p<<endl;这一行不可以执行，void*指针只可以储存变量地址，不可以直接操作它指向的对象

由于void是空类型，只保存了指针的值，而丢失了类型信息，我们不知道他指向的数据是什么类型的，只指定这个数据在内存中的起始地址，如果想要完整的提取指向的数据，程序员就必须对这个指针做出正确的类型转换，然后再解指针。

数组和指针

• 同类型指针变量可以相互赋值，数组不行，只能一个一个元素的赋值或拷贝
• 数组在内存中是连续存放的，开辟一块连续的内存空间。数组是根据数组的下进行访问的。指针很灵活，它可以指向任意类型的数据。指针的类型说明了它所指向地址空间的内存。
• 数组所占存储空间的内存：sizeof（数组名） 数组的大小：sizeof（数组名）/sizeof（数据类型），在32位平台下，无论指针的类型是什么，sizeof（指针名）都是 4 ，在 64 位平台下，无论指针的类型是什么，sizeof（指针名）都是 8 。
• 数组名作为右值的时候，就是第一个元素的地址
  

int main(void)
8 ]1 N2 ^0 y7 `& d/ p6 P9 x4 X{
    int arr[5] = {1,2,3,4,5};

$ \" w& b$ S0 r$ X- D    int *p_first = arr;
    printf("%d",*p_first);  //1
    return 0;
2 m$ W2 _+ x" G7 w}
: g( Q+ S4 T% k* a$ v/ `0 u1 j

• 指向数组元素的指针 支持 递增 递减 运算。p= p+1意思是，让p指向原来指向的内存块的下一个相邻的相同类型的内存块。在数组中相邻内存就是相邻下标元素。
  

函数与指针函数的参数和指针

C语言中，实参传递给形参，是按值传递的，也就是说，函数中的形参是实参的拷贝份，形参和实参只是在值上面一样，而不是同一个内存数据对象。这就意味着：这种数据传递是单向的，即从调用者传递给被调函数，而被调函数无法修改传递的参数达到回传的效果。

void change(int a)
{
    a++;      //在函数中改变的只是这个函数的局部变量a，而随着函数执行结束，a被销毁。age还是原来的age，纹丝不动。
4 w! Q+ D( a7 C5 V9 T9 P}
int main(void)
{
8 [6 U$ Z' S. e4 s% Q- Q2 P    int age = 60;
    change(age);
* B8 V/ S# X: N) \1 E; d5 G, h" K    printf("age = %d",age);   // age = 60
    return 0;
}

有时候我们可以使用函数的返回值来回传数据，在简单的情况下是可以的，但是如果返回值有其它用途（例如返回函数的执行状态量），或者要回传的数据不止一个，返回值就解决不了了。

传递变量的指针可以轻松解决上述问题。

void change(int* pa)
{
    (*pa)++;   //因为传递的是age的地址，因此pa指向内存数据age。当在函数中对指针pa解地址时，
               //会直接去内存中找到age这个数据，然后把它增1。
}
int main(void)
  I* s' P. }4 n* R% Z4 s2 r{
  {0 Y. e. W8 W. |2 M2 p8 O    int age = 160;
    change(&age);
) ^' X+ m" f  F8 N    printf("age = %d",age);   // age = 61
( w. g7 C) Y8 l: U* _    return 0;
, }9 m) d* R) D  e7 J}

比如指针的一个常见的使用例子：

#include <stdio.h>
' C' }% @3 V6 n& Z, P+ f#include <stdlib.h>
#include <string.h>
3 N# l" A& G( C0 x
void swap(int *,int *);
1 X# |4 l3 T, _  i- Iint main()
% s# X& q3 x$ y! w{
5 x; A1 I& ~3 l) e/ Z% M    int a=5,b=10;
    printf("a=%d,b=%d\n",a,b);
6 L  F2 C8 D8 m+ i% ^  W! D1 k    swap(&a,&b);
6 ^* P$ x0 o1 _! J% F, G    printf("a=%d,b=%d\n",a,b);
$ I$ f+ n7 L7 y" l4 a' ~  K    return 0;
" `( k& U( Z4 ?7 J}
/ A4 G8 L) N2 [8 k2 l; W" {( e9 Zvoid swap(int *pa,int *pb)
. k% S) J* }  C, F9 T, r3 e& k{
    int t=*pa;*pa=*pb;*pb=t;
( q# `- q; S" a5 _6 i5 t}
; C5 W& F$ E: I4 @8 s: X

在以上的例子中，swap函数的两个形参pa和pb可以接收两个整型变量的地址，并通过间接访问的方式修改了它指向变量的值。在main函数中调用swap时，提供的实参分别为&a,&b，这样就实现了pa=&a,pb=&b的赋值过程，这样在swap函数中就通过*pa修改了 a 的值，通过*pb修改了 b 的值。因此，如果需要在被调函数中修改主调函数中变量的值，就需要经过以下几个步骤：

• 定义函数的形参必须为指针类型，以接收主调函数中传来的变量的地址；
• 调用函数时实参为变量的地址；
• 在被调函数中使用*间接访问形参指向的内存空间，实现修改主调函数中变量值的功能。
  

指针作为函数的形参的另一个典型应用是当函数有多个返回值的情形。比如，需要在一个函数中统计一个数组的最大值、最小值和平均值。当然你可以编写三个函数分别完成统计三个值的功能。但比较啰嗦，如：

int GetMax(int a[],int n)
{
9 W2 N% l4 k% M) [  K# y    int max=a[0],i;
    for(i=1;i<n;i++)
    {
! g0 D0 T, H# C* f3 e  z; C        if(max<a) max=a;
( Y* _& m0 X" o0 M    }
# l0 }/ E/ B: W: `" p0 N* W    return max;
}
& K+ h$ D4 \- Wint GetMin(int a[],int n)
{
! ]/ e7 L5 @# V5 F. ?    int min=a[0],i;
; r2 n  J8 t1 V' b$ P. L0 _: B    for(i=1;i<n;i++)
3 M5 t! H' t% H    {
        if(min>a) min=a;
! }( t6 C9 B& e& u6 {    }
! D4 m, I. r5 D* B# a# b    return min;
}
- D- D  c* ]# ~double GetAvg(int a[],int n)
{
    double avg=0;
& k2 y6 Z; n  g% O- W6 t    int i;
, r2 m5 s: J$ Q4 n& a    for(i=0;i<n;i++)
2 q4 V. _+ |1 x* {2 A' Q1 W    {
; G6 \- d  O5 u: q! p+ \1 `        avg+=a;
    }
3 |: }9 U9 L; @( N. F5 |# h% B5 K    return avg/n;
$ ]. a) m( q! H8 @* u7 U}

其实我们完全可以在一个函数中完成这个功能，由于函数只能有一个返回值，可以返回平均值，最大值和最小值可以通过指针类型的形参来进行实现：

double Stat(int a[],int n,int *pmax,int *pmin)
{
    double avg=a[0];
    int i;
    *pmax=*pmin=a[0];
: J/ J: p" C& r6 @% W( C$ `+ b    for(i=1;i<n;i++)
  C$ I' g- x) i( D4 [    {
        avg+=a;
2 G' Z' Y' t6 r8 X/ B! t        if(*pmax<a) *pmax=a;
        if(*pmin>a) *pmin=a;
    }
) I; e- a- w, O    return avg/n;
}
: q6 |" m  e( }函数的指针

一个函数总是占用一段连续的内存区域，函数名在表达式中有时也会被转换为该函数所在内存区域的首地址。我们可以把函数的这个首地址赋予一个指针变量，使指针变量指向函数所在的内存区域，然后通过指针变量就可以找到并调用该函数。这种指针就是函数指针。

函数指针的定义形式为：

returnType (*pointerName)(param list);

returnType 为函数返回值类型，pointerNmae 为指针名称，param list 为函数参数列表。参数列表中可以同时给出参数的类型和名称，也可以只给出参数的类型，省略参数的名称，这一点和函数原型非常类似。

用指针来实现对函数的调用：

#include <stdio.h>
# t% |; {9 ^# y+ ~) [/ h' k//返回两个数中较大的一个
) k( n0 |- U& Iint max(int a, int b)
6 L/ {7 g1 B7 K2 [6 d7 ~3 s4 W{
& Y2 G4 n! z& C4 {; M    return a>b ? a : b;
& }. v/ D% u3 |}
4 _5 c/ H3 J& r2 cint main()
/ _8 _0 J1 Q* w& `/ M) s/ _{
    int x, y, maxval;
    //定义函数指针
    int (*pmax)(int, int) = max;  //也可以写作int (*pmax)(int a, int b)
    printf("Input two numbers:");
    scanf("%d %d", &x, &y);
' R; ^+ R! x: |6 w3 k( p  |# c    maxval = (*pmax)(x, y);
    printf("Max value: %d\n", maxval);
    return 0;
}
结构体和指针

结构体指针有特殊的语法： -> 符号

如果p是一个结构体指针，则可以使用 p ->【成员】 的方法访问结构体的成员

typedef struct
{
    char name[31];
    int age;
    float score;
  G) M# D) f& L' M. V0 A}Student;

8 }+ H" T! r1 K8 ?3 P2 Jint main(void)
{
  ]. Z1 {7 {3 u$ z+ f    Student stu = {"Bob" , 19, 98.0};
; C' n5 G% o$ u  u! E: R8 W" v- l6 p    Student*ps = &stu;
0 F/ D- z0 }* |# j+ [( W( |1 c
    ps->age = 20;
: U" q, G% M" F9 e: W    ps->score = 99.0;
    printf("name:%s age:%d
7 |& P+ ?0 t9 t4 i" a",ps->name,ps->age);
    return 0;
}
6 }5 ~9 ~1 e4 ~' Q, `3 D- A/ econst 和 指针

• 指向常量的指针，值不能改变，指向可改变
• 常指针值能改变，指向不可改变
• 指向常量的常指针，都不能改变
  

#include <stdio.h>
* o6 V, u0 P7 d+ c/ v
int main()
{
- X4 ^8 H6 x  ~' R  // 1 可改变指针
  const int a = 10;
  int *p = &a;
  *p = 1000;
' C2 z  ^" R0 w) B% p. z$ X7 f+ r  printf("*p = %d\n", *p);
5 k6 m  g' D8 w9 |: m! S' \% U
  // 2 可改变指针
4 w% a2 |3 f% V- p  const b = 10;
! C2 B) l4 G: G$ z3 E9 H  int *pb = &b;
  pb = p;
! F0 B8 L; q- p4 R7 W- d, ~  printf("*pb = %d\n", *pb);

/ s0 w6 h8 U7 ?  // 3
  const c = 10;
! O# V& G1 c! ?  int * const pc = &c;
$ D8 C! j  B) I$ y1 w  *pc = 1000;
  //pc = pb;不能改变
2 ~) v: |/ k' S! _! d
  //4
  const d = 10;
: L7 ?+ z. a. S) t# X. d% c9 w: Q  const * int const pd = &d;
  //*pd = 1000; 不能改变


) K! K3 y2 P: o8 ~* V  printf("\n");
9 B  H; \" A: T2 A" r  return 0;
5 U9 A7 X5 x$ }}
. i* m, `" S. ?& M! n) J深拷贝和浅拷贝

如果2个程序单元（例如2个函数）是通过拷贝 他们所共享的数据的 指针来工作的，这就是浅拷贝，因为真正要访问的数据并没有被拷贝。如果被访问的数据被拷贝了，在每个单元中都有自己的一份，对目标数据的操作相互 不受影响，则叫做深拷贝。

! }8 R# P3 Z! D# l#include <iostream>
using namespace std;

1 S, n: L& G. {9 Dclass CopyDemo
& p& A9 q5 I7 M9 H, }8 s2 s5 {{
5 e+ @# E$ r  f  H; E" |public:
  CopyDemo(int pa,char *cstr)  //构造函数，两个参数
  {
     this->a = pa;
     this->str = new char[1024]; //指针数组，动态的用new在堆上分配存储空间
  w* [' F# s& i" K; K" E9 J     strcpy(this->str,cstr);    //拷贝过来
! f" Y, t+ y# C8 b7 ?  }
' c, U+ q, D. f. v( n
: N: [% C7 f& u1 N//没写，C++会自动帮忙写一个复制构造函数，浅拷贝只复制指针,如下注释部分
  //CopyDemo(CopyDemo& obj)  
# _9 r/ H3 e9 }7 j6 ]8 ?  //{
+ B9 D# X( ?8 ^7 d9 @  //   this->a = obj.a;
  //  this->str = obj.str; //这里是浅复制会出问题，要深复制
  //}

8 H0 Y0 |8 ?8 N! A  CopyDemo(CopyDemo& obj)  //一般数据成员有指针要自己写复制构造函数，如下
  {
9 }/ _  A8 R' m6 S     this->a = obj.a;
; x+ j7 M0 G3 {    // this->str = obj.str; //这里是浅复制会出问题，要深复制
7 I: r  T# T9 C7 U" F     this->str = new char[1024];//应该这样写
     if(str != 0)
        strcpy(this->str,obj.str); //如果成功，把内容复制过来
  }

  ~CopyDemo()  //析构函数
& v% j7 d1 o; y7 d" k- Y  {
     delete str;
5 }7 j% k9 e8 X3 c1 Z  }

3 M5 f4 f: N: ^6 v9 cpublic:
     int a;  //定义一个整型的数据成员
4 [& |! z& b( U2 q     char *str; //字符串指针
' g" J/ G4 H7 ?( }& p6 `};
* k9 \7 J; f, x8 C1 W7 f7 E
int main()
4 Q' B5 \/ W9 m# `{
6 C3 L- `. s0 J+ p/ c  CopyDemo A(100,"hello!!!");
- b# W2 x8 Y" n: }
3 K* ]7 M# p- v" k- V3 G  CopyDemo B = A;  //复制构造函数，把A的10和hello!!!复制给B
/ f1 p$ K2 x3 k# z  cout <<"A:"<< A.a << "," <<A.str << endl;
9 Z8 q# |$ N; ]9 {! Q  //输出A:100，hello!!!
, a' L9 {* ?5 o6 A$ Z/ K  cout <<"B:"<< B.a << "," <<B.str << endl;
  //输出B:100，hello!!!
% w- O' k$ X: u' f7 l# z4 z+ Y
4 F& l' f( P6 }  //修改后,发现A,B都被改变，原因就是浅复制，A,B指针指向同一地方，修改后都改变
9 h, C3 D, b* e  B.a = 80;
  B.str[0] = 'k';

/ ?5 p; Q5 |8 D% V# h: d  cout <<"A:"<< A.a << "," <<A.str << endl;
  //输出A:100，kello!!!
  cout <<"B:"<< B.a << "," <<B.str << endl;
% V3 E- {! F. y/ ^! `& K- v& v  //输出B:80，kello!!!

  return 0;
) k6 s7 K" r$ A  }- c/ z}

根据上面实例可以看到，浅复制仅复制对象本身（其中包括是指针的成员），这样不同被复制对象的成员中的对应非空指针会指向同一对象，被成员指针引用的对象成为共享的，无法直接通过指针成员安全地删除（因为若直接删除，另外对象中的指针就会无效，形成所谓的野指针，而访问无效指针是危险的；

除非这些指针有引用计数或者其它手段确保被指对象的所有权）；而深复制在浅复制的基础上，连同指针指向的对象也一起复制，代价比较高，但是相对容易管理。

谢谢分享~~~

好文章