category: cpp
参考书籍:
C++ Primer
Essential C++
编译器:
gcc / g++
C++构造和析构
构造函数
- 名字和类名相同
- 没有返回值
- 构造函数是用来构造对象，构造对象时候必定调用构造函数
- 不写构造函数，存在一个默认的构造函数，默认的构造函数是无参，所以可以构造无参对象
- 默认的构造函数可以删掉，通过delete删除默认的构造函数
- 显示使用默认的构造函数, 通过default做显示调用
- 通常情况构造函数是public属性
- 自己写了构造函数，默认的构造函数就不存在了
- 构造函数决定对象的长相(构造函数无参，对象无参，构造有一个，对象必须也要一个参数)
- 构造函数通常做的事情，就是给数据成员初始化
- 构造函数也是函数，所以也可以重载，也可以缺省
- 通过重载和缺省，实现构造不同长相对象
#include <iostream>
#include <string>
using namespace std;
class MM {
public:
// MM() = default; //显式使用默认的构造函数
// MM() = delete; //删掉默认的构造函数
MM(string name, int age) {
m_name = name;
m_age = age;
cout << "两个参数的构造函数" << endl;
}
MM() = default; //默认无参构造函数，据说速度更快
void printMM() {
cout << m_name << "\t" << m_age << endl;
}
protected:
string m_name;
int m_age;
};
// MM::MM()
//{
// cout << "调用无参构造函数" << endl;
// }
struct Boy {
string name;
int age;
int num;
//一旦C++结构体中写了构造函数，必须当做类去操作，不能用C语言的那种方式使用
Boy() {}
Boy(string bname, int bage) {
name = bname;
age = bage;
}
};
void testStruct() {
// Boy boy = { "string",18,1001}; //错误
//这个地方也是创建对象过程，所以数据也需要和构造函数
Boy boy = {"string", 18}; //这里数据必须和构造函数的一致
Boy boy2;
Boy array[3];
}
int main(int argc, char** argv) {
// MM mm;
// //因为构造函数有两个参数，对象也必须带有两参数
MM mm("对象", 18); //这步创建对象的过程就是调用构造函数构造函数的过程
mm.printMM();
MM empty; //调用无参构造函数
// new一个对象
MM* p = new MM; //调用无参的构造函数
MM* p2 = new MM("对象", 29); //调用有参的构造函数
return 0;
}
析构函数
- ~类名 当做析构函数名字
- 没有参数
- 释放数据成员new的内存
- 在对象死亡前自动调用
- 通常如果数据成员没有做new操作，就可以不写析构函数
- 不写析构函数，存在一个默认的析构函数
#include <cstring>
#include <iostream>
using namespace std;
class MM {
public:
MM(const char* str ="ILoveyou") { //缺省,相当于存在两个构造函数，一个是无参的，一个是有参
int length = strlen(str) + 1;
name = new char[length];
strcpy(name, str);
}
~MM();
protected:
char* name;
};
MM::~MM() {
if (name != nullptr) {
delete[] name;
name = nullptr;
}
cout << "析构函数....\n" << endl;
}
int main(int argc, char** argv) {
{
MM mm;
MM* p = new MM;
cout << "1......" << endl;
delete p; //立刻调用析构函数
p = nullptr;
cout << "2......." << endl;
}
{
MM beauty("Continue");
}
cout << "对象死亡" << endl;
return 0;
}
拷贝构造函数
- 拷贝构造函数也是构造函数
- 拷贝构造函数参数是固定的:对对象的引用
- 拷贝构造函数不写会存在一个默认的拷贝构造函数
- 拷贝构造函数作用： 通过一个对象产生另一个对象
- 关键点：一定是有一个新的对象产生
#include <iostream>
#include <string>
using namespace std;
class MM {
public:
MM() {}
MM(string name, int age) {
m_name = name;
m_age = age;
}
MM(MM& object);
void printMM() {
cout << m_name << "\t" << m_age << endl;
}
protected:
string m_name;
int m_age;
};
//拷贝构造函数
//通过传入对象属性确定创建对象的属性
MM::MM(MM& object) {
m_name = object.m_name;
m_age = object.m_age;
cout << "调用自己写的拷贝构造函数" << endl;
}
//函数传参也可以隐式调用
void print(MM object) { // MM object=girl
object.printMM();
}
// C++中传参能用引用就用，效率搞
void printData(MM& object) { //引用就是别名，没有产生新的对象
object.printMM();
}
int main(int argc, char** argv) {
MM mm("C神", 18);
//产生一个对象
MM beauty = mm; //隐式调用拷贝构造函数
MM girl(beauty); //显式调用拷贝构造函数
print(girl); //调用拷贝构造函数
printData(girl);
MM boy;
//对象先有了，才赋值，不调用拷贝
boy = girl; //不调用拷贝构造函数-->默认重载=运算符(后续会详细阐述)
return 0;
}
深浅拷贝问题
浅拷贝
- 没有在拷贝构造函数中给数据成员做new操作
- 默认拷贝构造函数都是浅拷贝
深拷贝
- 在拷贝构造函数中做了new操作
浅拷贝导致内存释放问题
浅拷贝会导致同一段内存重复释放问题
#include <cstring>
#include <iostream>
using namespace std;
class MM {
public:
MM() {}
MM(const char* str) {
int length = strlen(str) + 1;
name = new char[length];
strcpy(name, str);
}
// MM(MM& object) {
// name = object.name;
// }
~MM() {
if (name != nullptr) { //浅拷贝导致内存释放问题
//浅拷贝会导致同一段内存重复释放问题
//两个指针都指向同一段内存
delete[] name;
name = nullptr;
}
}
private:
char* name;
};
int main(int argc, char** argv) {
{
MM girl("girl");
MM mm = girl; //调用拷贝构造函数
}
return 0;
}
深拷贝解决方案
#include <cstring>
#include <iostream>
using namespace std;
class MM {
public:
MM() {}
MM(const char* str) {
int length = strlen(str) + 1;
name = new char[length];
strcpy(name, str);
}
MM(MM& object) {
// name = object.name;
int length = strlen(object.name) + 1;
name = new char[length];
strcpy(name, object.name);
}
~MM() {
if (name != nullptr) {
delete[] name;
name = nullptr;
}
}
private:
char* name;
};
int main(int argc, char** argv) {
{
MM girl("girl");
MM mm = girl; //调用拷贝构造函数
}
return 0;
}
综上： 一旦类中有指针，做了内存申请，并且要对对象做拷贝操作，就必须使用深拷贝
匿名对象
匿名对象就是无名对象，匿名对象只能充当右值，所以匿名对象拷贝必须存在移动拷贝，或者准备一个ecosnt限定普通拷贝构造函数。
#include <iostream>
#include <string>
using namespace std;
class MM {
public:
MM(){};
MM(string name, int age) {
m_name = name;
m_age = age;
}
void printMM() {
cout << m_name << "\t" << m_age << endl;
}
MM(MM& object) {
m_name = object.m_name;
m_age = object.m_age;
}
//移动构造--->新标准的
MM(MM&& object) {
m_name = object.m_name;
m_age = object.m_age;
cout << "调用移动构造" << endl;
}
~MM() {
cout << "析构打印name:" << m_name << endl;
}
private:
string m_name;
int m_age;
};
MM returnMM(string name, int age) {
return MM(name, age); //构造一个匿名对象当做函数返回值
}
int main(int argc, char** argv) {
{
MM girl("girl", 19);
//匿名对象是一个右值
MM mm = MM("mm", 29); //匿名对象 --->匿名对象转正 ，mm接管所有权
cout << "匿名对象已死亡" << endl;
}
MM beauty = returnMM("返回值", 18);
beauty.printMM();
return 0;
}
构造和析构顺序问题
- 一般情况构造顺序和析构是相反的
- 静态的和全局的是最后释放的
- delete 立刻调用析构函数
#include <iostream>
#include <string>
using namespace std;
class Test {
public:
Test(string data = "A") {
m_data = data;
cout << m_data;
}
~Test() { cout << m_data; }
protected:
string m_data;
};
int main(int argc, char** argv) {
{
Test t1; // A
static Test t2("B"); // B
Test array[3]; // AAA //数组就是多个无参
Test* p = new Test("C"); // C
delete p; // C
p = nullptr;
}
// ABAAACCAAAAB
return 0;
}
//用构造函数的方式简单实现单链表
#include <iostream>
using namespace std;
struct Node {
int data;
Node* next;
Node() : next(nullptr) {}
Node(int data) : data(data), next(nullptr) {}
Node(int data, Node* next) : data(data), next(next) {}
};
class List {
public:
List();
void insertData(int data);
void printList() {
Node* pmove = headNode->next;
while (pmove != nullptr) {
cout << pmove->data << " ";
pmove = pmove->next;
}
cout << endl;
}
private:
Node* headNode;
};
List::List() {
headNode = new Node;
}
void List::insertData(int data) {
headNode->next = new Node(data, headNode->next);
}
int main(int argc, char** argv) {
List list;
list.insertData(1);
list.insertData(2);
list.insertData(3);
list.printList();
return 0;
}
