二、类的声明与函数

个人认为，类相对于结构体就好比结构体相对于数组，逻辑功能实现的可操作幅度与深度更上一层楼。C++中，类的使用方式和结构体有点像，下面就以结构体引入C++的类。

例7-1、往数组尾部追加数据

arr.h

#ifndef _ARR_
#define _ARR_typedef struct arr{int data[100];int tail;
}ARR;void init(ARR *arr);
void addtail(ARR *arr, int data);
void show(ARR *arr);#endif

arr.c

#include "arr.h"
#include <stdio.h>void init(ARR *arr)
{arr->tail = 0;
}void addtail(ARR *arr, int data)
{arr->data[arr->tail++] = data;
}void show(ARR *arr)
{int i = 0;for(;i<arr->tail; i++)printf("%d, ", arr->data[i]);printf("\n");
}

main.c

#include "arr.h"int main()
{ARR arr;init(&arr);int n = 10;while(n--)addtail(&arr, n);show(&arr);int i = 0;for(;i<10; i++)addtail(&arr, i);show(&arr);
}

结果：

@ubuntu:/mnt/hgfs/ub2/ARR1$ ls
arr.c  arr.h  main.c
@ubuntu:/mnt/hgfs/ub2/ARR1$ gcc *.c
@ubuntu:/mnt/hgfs/ub2/ARR1$ ./a.out 
9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 
9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
@ubuntu:/mnt/hgfs/ub2/ARR1$ 

例7-2、往数组尾部追加数据(优化版)

在例7-1里的void addtail(ARR *arr, int data);和void show(ARR *arr);没有被限制，外部可直接访问。这样就会存在数据被无意中篡改的风险。换句话说，希望这些函数绑定在一块，需要初始化后才能使用，让代码安全性提高。高级官方代码很多都长这样的。

玩stm32单片机使用过STM32CubeMX生成的代码的朋友们对此肯定不会陌生，从另一个方面来说，做嵌入式单片机开发肯定要面对这些的吧

arr.h

#ifndef _ARR_
#define _ARR_typedef struct arr{int data[100];int tail;void (*addtail)(struct arr *arr, int data);void (*show)(struct arr *arr);
}ARR;void init(struct arr *arr);#endif

arr.c

#include "arr.h"
#include <stdio.h>static void addtail(ARR *arr, int data)
{arr->data[arr->tail++] = data;
}static void show(ARR *arr)
{int i = 0;for(;i<arr->tail; i++)printf("%d, ", arr->data[i]);printf("\n");
}void init(ARR *arr)
{arr->tail = 0;arr->addtail = addtail;arr->show = show;
}

main.c

#include "arr.h"int main()
{ARR arr;init(&arr);int n = 10;while(n--)arr.addtail(&arr, n);arr.show(&arr);int i = 0;for(;i<10; i++)arr.addtail(&arr, i);arr.show(&arr);}

结果：

@ubuntu:/mnt/hgfs/ub2/ARR2$ ls
arr.c  arr.h  main.c
@ubuntu:/mnt/hgfs/ub2/ARR2$ gcc *.c
@ubuntu:/mnt/hgfs/ub2/ARR2$ ./a.out 
9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 
9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
@ubuntu:/mnt/hgfs/ub2/ARR2$ 

上面的例7-2的结构体里边使用了函数指针，让指向的函数成为结构体的下属（调用时得写成arr.addtail()和arr.show()），充分展现出了封装的思想以及面向对象的概念。体现的还有回调的思想（相信懂stm32开发的朋友们在此应该会对回调函数的理解更加深刻）。

typedef struct arr{int data[100];int tail;//两个函数指针void (*addtail)(struct arr *arr, int data);void (*show)(struct arr *arr);
}ARR;

1、类的声明

例7-3、往数组尾部追加数据(C++版)

arr.h

#ifndef _ARR_
#define _ARR_class ARR{
public:void addtail(int data);void show(void);private:int data[100];int tail;
};#endif

arr.cpp

#include "arr.h"
#include <stdio.h>void ARR::addtail(int data)
{this->data[tail++] = data;//this关键字标识的是类ARR里的成员（int data[100];的data），与所传参数名（void ARR::addtail(int data)的data）区分开来
}void ARR::show(void)
{int i = 0;for(;i<tail; i++)printf("%d, ", data[i]);printf("\n");
}

main.cpp

#include "arr.h"int main()
{ARR arr;int n = 10;while(n--)arr.addtail(n);arr.show();int i = 0;for(;i<10; i++)arr.addtail(i);arr.show();}

结果：

@ubuntu:/mnt/hgfs/ub2/ARR3$ ls
arr.cpp  arr.h  main.cpp
@ubuntu:/mnt/hgfs/ub2/ARR3$ g++ *.cpp
@ubuntu:/mnt/hgfs/ub2/ARR3$ ./a.out 
9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 
9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
@ubuntu:/mnt/hgfs/ub2/ARR3$ 

2、类的成员函数

1. 构造函数A()
2. 析构函数~A()
3. 普通成员函数

例8-1、隐式构造的存在->以析构函数判断创建几个对象

先是声明类A，然后通过打印析构函数信息来调试。

#include <stdio.h>class A{
public:~A(){printf("A~~~~~~~~~~~~~\n");}
};int main()
{A  x ;A  y = x;
}

结果：

@ubuntu:/mnt/hgfs/ub2/class$ g++ class_1.cpp 
@ubuntu:/mnt/hgfs/ub2/class$ ./a.out 
A~~~~~~~~~~~~~
A~~~~~~~~~~~~~
@ubuntu:/mnt/hgfs/ub2/class$ 

由结果不难发现：析构函数执行了两次，所以得出创建了2个对象。

可以确定构造函数是能够默认执行的，那么，构造函数有执行2次吗？可以写点构造函数的内容测试一下。

#include <stdio.h>class A{
public:A(){printf("A\n");}~A(){printf("A~~~~~~~~~~~~~\n");}
};int main()
{A  x ;A  y = x;
}

结果：

@ubuntu:/mnt/hgfs/ub2/class$ g++ class_2.cpp 
@ubuntu:/mnt/hgfs/ub2/class$ ./a.out 
A
A~~~~~~~~~~~~~
A~~~~~~~~~~~~~
@ubuntu:/mnt/hgfs/ub2/class$ 

从结果可以发现，构造函数显示出来只有一个，是少构造一个吗？并不是。这里并不是少了个构造函数，而是那个构造函数是隐式构造，是A y = x执行的情况，这里用的是拷贝构造函数。拷贝构造函数执行了系统默认的创建对象，而忽略调自定义的无参构造函数内容printf(“A\n”)

以上的是无参构造函数。但很多时候函数是需要传参的，于是就需要使用有参构造函数。

例8-2、有参构造函数

在使用有参构造函数时如果还需要存在默认情况的无参构造函数，就需要写出无参构造函数来。

#include <stdio.h>class A{
public:A(){printf("A\n");}A(int data){printf("A(int data)\n");}~A(){printf("A~~~~~~~~~~~~~\n");}
};int main()
{A  x = 10; A  y;
}

结果：

@ubuntu:/mnt/hgfs/ub2/class$ g++ class_3.cpp 
@ubuntu:/mnt/hgfs/ub2/class$ ./a.out 
A(int data)
A
A~~~~~~~~~~~~~
A~~~~~~~~~~~~~
@ubuntu:/mnt/hgfs/ub2/class$ 

这里的A x = 10; 和A x(10);都是传参之意。

如果保持默认情况的不写出来就会报错，如下：

#include <stdio.h>class A{
public:A(int data){printf("A(int data)\n");}~A(){printf("A~~~~~~~~~~~~~\n");}
};int main()
{A  x = 10;A  y;
}

错误结果：

@ubuntu:/mnt/hgfs/ub2/class$ g++ class_4.cpp 
class_construct.cpp: In function ‘int main()’:
class_construct.cpp:17:5: error: no matching function for call to ‘A::A()’A  y;^
class_construct.cpp:5:2: note: candidate: A::A(int)A(int data)^
class_construct.cpp:5:2: note:   candidate expects 1 argument, 0 provided
class_construct.cpp:3:7: note: candidate: A::A(const A&)class A{^
class_construct.cpp:3:7: note:   candidate expects 1 argument, 0 provided
@ubuntu:/mnt/hgfs/ub2/class$ 

例8-3、深拷贝与浅拷贝

在了解有参构造函数后，接下来讨论一下例8-1中的拷贝构造函数。

#include <stdio.h>class A{
public:A(){printf("A\n");}A(int data){printf("A(int data)\n");}~A(){printf("A~~~~~~~~~~~~~\n");}
};int main()
{A  w(10);A  x = 10;A  y = x;A  z;
}

结果：

@ubuntu:/mnt/hgfs/ub2/class$ g++ class_5.cpp 
@ubuntu:/mnt/hgfs/ub2/class$ ./a.out 
A(int data)
A(int data)
A
A~~~~~~~~~~~~~
A~~~~~~~~~~~~~
A~~~~~~~~~~~~~
A~~~~~~~~~~~~~
@ubuntu:/mnt/hgfs/ub2/class$ 

根据结果可以知道，A y = x; 没有执行自定义的构造函数内容printf(“A\n”)，而是执行系统默认的空白构造函数然后拷贝对象x的数据来作为y自己的数据。

俗点说就是：自定义创建的对象x带数据，创建的对象z也是自定义的，但对象y是由系统创建然后用了自定义对象x的数据，相当于例中的渣数据10有了对象x然后又去跟对象y搞。这就很有问题对吧。因为哪天对象x发现这渣渣有了对象y然后干掉渣渣（对象x把数据释放），渣渣被干掉肯定就会给对象y造成影响。这就是浅拷贝。

而深拷贝就是数据真正意义上的一分为二，双胞胎。老哥有对象x，小老弟有对象y。哪天老哥被对象x榨干了，但小老弟精力旺盛，对象y根本不受影响。

下面是会出错的浅拷贝：

#include <stdio.h>class A{
public:A(){printf("A()\n");p = new char[10];}~A(){printf("~A()\n");delete [] p;}private:char *p;
};int main()
{A x;A y = x;}

错误结果：

@ubuntu:/mnt/hgfs/ub2/class$ g++ class_6.cpp 
@ubuntu:/mnt/hgfs/ub2/class$ ./a.out 
A()
~A()
~A()
*** Error in `./a.out': double free or corruption (fasttop): 0x00000000006e7030 ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x777f5)[0x7f8211ee97f5]
/lib/x86_64-linux-gnu/libc.so.6(+0x8038a)[0x7f8211ef238a]
/lib/x86_64-linux-gnu/libc.so.6(cfree+0x4c)[0x7f8211ef658c]
./a.out[0x4008d5]
./a.out[0x40083a]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f8211e92840]
./a.out[0x400729]
======= Memory map: ========
00400000-00401000 r-xp 00000000 00:2d 75348                              /mnt/hgfs/ub2/level14/1day/class/a.out
00600000-00601000 r--p 00000000 00:2d 75348                              /mnt/hgfs/ub2/level14/1day/class/a.out
00601000-00602000 rw-p 00001000 00:2d 75348                              /mnt/hgfs/ub2/level14/1day/class/a.out
006d5000-00707000 rw-p 00000000 00:00 0                                  [heap]
7f820c000000-7f820c021000 rw-p 00000000 00:00 0 
7f820c021000-7f8210000000 ---p 00000000 00:00 0 
7f8211b69000-7f8211c71000 r-xp 00000000 08:01 669534                     /lib/x86_64-linux-gnu/libm-2.23.so
7f8211c71000-7f8211e70000 ---p 00108000 08:01 669534                     /lib/x86_64-linux-gnu/libm-2.23.so
7f8211e70000-7f8211e71000 r--p 00107000 08:01 669534                     /lib/x86_64-linux-gnu/libm-2.23.so
7f8211e71000-7f8211e72000 rw-p 00108000 08:01 669534                     /lib/x86_64-linux-gnu/libm-2.23.so
7f8211e72000-7f8212032000 r-xp 00000000 08:01 669539                     /lib/x86_64-linux-gnu/libc-2.23.so
7f8212032000-7f8212232000 ---p 001c0000 08:01 669539                     /lib/x86_64-linux-gnu/libc-2.23.so
7f8212232000-7f8212236000 r--p 001c0000 08:01 669539                     /lib/x86_64-linux-gnu/libc-2.23.so
7f8212236000-7f8212238000 rw-p 001c4000 08:01 669539                     /lib/x86_64-linux-gnu/libc-2.23.so
7f8212238000-7f821223c000 rw-p 00000000 00:00 0 
7f821223c000-7f8212252000 r-xp 00000000 08:01 658907                     /lib/x86_64-linux-gnu/libgcc_s.so.1
7f8212252000-7f8212451000 ---p 00016000 08:01 658907                     /lib/x86_64-linux-gnu/libgcc_s.so.1
7f8212451000-7f8212452000 rw-p 00015000 08:01 658907                     /lib/x86_64-linux-gnu/libgcc_s.so.1
7f8212452000-7f82125c4000 r-xp 00000000 08:01 1057509                    /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21
7f82125c4000-7f82127c4000 ---p 00172000 08:01 1057509                    /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21
7f82127c4000-7f82127ce000 r--p 00172000 08:01 1057509                    /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21
7f82127ce000-7f82127d0000 rw-p 0017c000 08:01 1057509                    /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.21
7f82127d0000-7f82127d4000 rw-p 00000000 00:00 0 
7f82127d4000-7f82127fa000 r-xp 00000000 08:01 667754                     /lib/x86_64-linux-gnu/ld-2.23.so
7f82129d9000-7f82129df000 rw-p 00000000 00:00 0 
7f82129f8000-7f82129f9000 rw-p 00000000 00:00 0 
7f82129f9000-7f82129fa000 r--p 00025000 08:01 667754                     /lib/x86_64-linux-gnu/ld-2.23.so
7f82129fa000-7f82129fb000 rw-p 00026000 08:01 667754                     /lib/x86_64-linux-gnu/ld-2.23.so
7f82129fb000-7f82129fc000 rw-p 00000000 00:00 0 
7ffc6e46b000-7ffc6e48c000 rw-p 00000000 00:00 0                          [stack]
7ffc6e573000-7ffc6e576000 r--p 00000000 00:00 0                          [vvar]
7ffc6e576000-7ffc6e578000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
Aborted (core dumped)
@ubuntu:/mnt/hgfs/ub2/class$ 

上面错误信息中有double free or corruption，说明了问题所在。对象x申请一片内存空间，对象y用了已申请的内存空间，由于析构时执行两次，即释放两次内存而实际只申请到一片，所以就报错double free。

下面的是深拷贝：

#include <stdio.h>
#include <string.h>class A{
public:A(){printf("A()\n");p = new char[10];strcpy(p, "hello");}A(const A &x){printf("const A()\n");p = new char[10];strcpy(p, x.p);}~A(){printf("~A()\n");delete [] p;}private:char *p;
};int main()
{A x;A y = x;}

结果：

@ubuntu:/mnt/hgfs/ub2/class$ g++ class_7.cpp 
@ubuntu:/mnt/hgfs/ub2/class$ ./a.out 
A()
const A()
~A()
~A()
@ubuntu:/mnt/hgfs/ub2/class$ 

从代码安全性方面来考虑，深拷贝是很有必要的。实际上深浅拷贝和我们复制粘贴东西是有相通之处的，浅拷贝相当于复制个快捷方式，而深拷贝则是整个全部文件包都要求复制。