前言
前面简单介绍了C++中的基本知识和引用，本篇博客将介绍C++中的类与函数，分别是成员函数、无参构造函数、有参构造函数、析构函数、拷贝构造函数等。
成员函数
类的成员函数有两种定义：一种是在声明类时就给出成员函数的定义；另一种是在声明类时，只声明成员函数的原型，然后在类的外部定义成员函数，其定义方法是：
返回类型 类名::成员函数名(参数表)
其中，::是域限定符，用于说明成员函数名是指定类名中的一个函数。这里我将就第二种举例子如下：
首先我们创建一个头文件MyTeacher.h
//防止被重复引用
#pragma once;
class MyTeacher {
private:
char* name;
int age;
public:
void setName(char* name);
char* getName();
void setAge(int age);
int getAge();
};
头文件中定义了类MyTeacher，声明了四个函数，#pragma once防止被重复引用。
再创建一个C++文件，用于上面四个函数的定义
#include "MyTeacher.h"
void MyTeacher::setName(char* name) {
this->name = name;
}
char* MyTeacher::getName() {
return this->name;
}
void MyTeacher::setAge(int age) {
this->age = age;
}
int MyTeacher::getAge() {
return this->age;
}
最后我们在另一个C++文件中去使用
#include<iostream>
#include<stdarg.h>
#include "MyTeacher.h"
using namespace std;
void main() {
MyTeacher t;
t.setName("john");
cout << t.getName() << endl;
getchar();
}
运行打印结果：
john
类成员函数的第二种定义方式在C++中是比较普遍的，需要了解一下。
无参构造函数
#include<iostream>
#include<stdarg.h>
using namespace std;
class Teacher {
private:
char* name;
int age;
public:
//无参构造函数(有默认的无参构造函数，如果添加了，就会覆盖默认的无参构造函数)
Teacher() {
cout << "无参构造函数" << endl;
}
};
void main() {
Teacher t1;
getchar();
}
运行打印结果：
无参构造函数
有参构造函数
添加有参构造函数，将无参构造函数注释
//有参构造函数会覆盖默认的无参构造函数
Teacher(char* name, int age) {
this->name = name;
this->age = age;
cout << "有参构造函数" << endl;
}
main函数中调用，将无参函数的调用注释
Teacher t2("john", 23);
//有参构造函数的另一种写法
//Teacher t2 = Teacher("john", 23);
运行打印输出结果为：
有参构造函数
析构函数
添加析构函数，将有参构造函数注释
~Teacher(){
cout << "析构函数" << endl;
}
编写一个函数，创建Teacher的引用
void func() {
Teacher t3;
}
main函数中调用func函数，将有参构造函数注释
func();
运行打印结果为：
析构函数
当对象要被释放时，析构函数会被调用，此例中的Teacher t3要被释放时，析构函数被调用。析构函数的作用就是做一些善后处理工作。接下来我们来模拟析构函数的善后处理工作。
将无参构造函数打开，并修改如下：
Teacher() {
this->name = (char*)malloc(100);
strcpy(this->name, "john");
cout << "无参构造函数" << endl;
}
析构函数将this->name内存通过free释放
~Teacher(){
free(this->name);
cout << "析构函数" << endl;
}
运行错误，在头文件上方添加
#define _CRT_SECURE_NO_WARNINGS
运行打印结果为：
无参构造函数
析构函数
拷贝构造函数
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class Teacher {
private:
char* name;
int age;
public:
Teacher(char* name, int age) {
this->name = name;
this->age = age;
cout << "有参构造函数" << endl;
}
//拷贝构造函数(值拷贝)
//默认拷贝构造函数就是值拷贝
Teacher(const Teacher &obj) {
this->name = obj.name;
this->age = obj.age;
cout << "拷贝构造函数" << endl;
}
void myPrintf() {
cout << this->name << "," << this->age << endl;
}
};
void main() {
Teacher t1 = Teacher("john", 23);
Teacher t2 = t1;
t2.myPrintf();
getchar();
}
拷贝构造函数的参数其实就是常引用，这下是不是对常引用的应用又了解了一波呢？默认拷贝构造函数就是值拷贝，也就是说如果不写任何拷贝函数，默认就是值拷贝，值拷贝又名浅拷贝。
拷贝构造函数被调用的场景：
1.声明时赋值
Teacher t2 = t1;
2.作为参数传入，实参给形参赋值
3.作为函数返回值返回，给变量初始化赋值
浅拷贝问题
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class Teacher {
private:
char* name;
int age;
public:
Teacher(char* name, int age) {
this->name = (char*)malloc(100);
strcpy(this->name, name);
this->age = age;
cout << "有参构造函数" << endl;
}
~Teacher() {
//释放内存
free(this->name);
cout << "析构函数" << endl;
}
};
void func() {
Teacher t1("jonh", 23);
Teacher t2 = t1;
}
void main() {
func();
getchar();
}
这里有参函数中通过动态内存的方式给this->name给予内存空间，在析构函数中释放内存。运行出现错误，错误信息大意就是程序试图删除一个空指针，结果为：
有参构造函数
析构函数
我们来分析一下执行的流程，首先执行t1的有参构造函数，给t1的this->name赋予内存空间，然后执行默认的浅拷贝，上面有说过浅拷贝其实就是值拷贝，而指针的值就是地址，所以会将t2的this->name赋予刚才一样的内存空间。这时候func函数执行完，将释放内部的局部变量，首先释放的是t2，而不是t1，对于此处不相信的同学可以在func函数中分别对t1、t2的age赋值为1，2，然后在析构函数中打印age的值，就可以知晓释放的先后顺序。言归正传，首先释放t2，将那块相同的内存空间释放，接下来再去调用析构函数，释放t1，这次就出现问题了，因为那块内存已经被释放了，不能再次释放。
默认的浅拷贝其实就是下面的逻辑原理：
Teacher(const Teacher &obj) {
this->name = obj.name;
this->age = obj.age;
cout << "拷贝构造函数" << endl;
}
深拷贝
解决浅拷贝问题：
Teacher(const Teacher &obj) {
this->name = (char*)malloc(100);
strcpy(this->name, obj.name);
this->age = age;
}
当Teacher t2 = t1时，调用拷贝函数，又在内存中开辟出一段内存空间，然后指针指向这段内存空间。
运行打印结果为：
有参构造函数
析构函数
析构函数
我们来简单分析一下运行结果：Teacher t1("jonh", 23)会执行有参构造函数，Teacher t2 = t1会调用拷贝构造函数，此时又在内存中开辟出一段内存空间，然后t2的name指针指向这段新开辟出来的内存空间，最后当func函数执行完之后，会首先释放t2，调用析构函数，接下来释放t1，由于之前t1和t2指向的内存空间不同，所以这时候释放t1是没有任何影响的，故而再次调用析构函数。
总结
浅拷贝（值拷贝），拷贝的是指针的地址
深拷贝，拷贝的是指针指向的数据内容
