目录
一.函数
1.内联函数
内涵函数的正确使用可以提升程序的执行效率。内联函数用于取代C语言中的宏定义函数。内联函数在编译的时候，直接把函数展开到主函数中进行编译，在运行期间减少调用的开销。
通常将具有以下性质的函数写为内联函数：
● 代码长度在5行以内
● 不包含复杂的控制语句
● 频繁的被调用
#include <iostream>
using namespace std;
inline void print_string(string str)
{
cout << str << endl;
}
int main()
{
print_string("helloworld");
return 0;
}
关键字：inline
后续学习的成员函数默认添加inline修饰。
我们手动添加上inline关键字，将函数声明为内联函数，。但是这个不是我们可以决定的，编译器有自己的判断准则。我们只是非常卑微的给编译器提一个建议，具体是否变为内联函数，还是编译器自己决定的。
2.函数重载
C++中允许多个函数使用同一个名称，这种用法就是函数重载。函数重载要求函数名称相同，但是参数不同（类型或者数量不同或者前后顺序不同）。与返回值类型等其他因素无关。
#include <iostream>
using namespace std;
void print_show(int i)
{
cout << "调用int重载：" << i << endl;
}
// 错误 名称相同，参数相同编译器无法区分
//void print_show(int i)
//{
// cout << "调用int重载：" << i << endl;
//}
void print_show(string str)
{
cout << "调用了string重载:" << str << endl;
}
//int print_show(const int i)
//{
// cout << "调用int2重载：" << i << endl;
//}
//void print_show(float i)
//{
// cout << "调用float重载：" << i << endl;
//}
void print_show(double i)
{
cout << "调用double重载：" << i << endl;
}
int main()
{
print_show(2.3);
return 0;
}
3.哑元函数
函数的参数只有类型，没有名称，有这样参数的函数就是哑元函数。
#include <iostream>
using namespace std;
// 哑元函数
void print_show(int)
{
cout << "调用了int哑元函数" << endl;
}
int main()
{
print_show(1);
return 0;
}
作用1：哑元函数用来区分函数重载
作用2：运算符重载中用到
作用3：保持向前兼容
二.类和对象
类：是一个抽象的概念，用于描述同一类对象的特征。在现在学习阶段，一个单独的类没有任何功能。
对象：根据类的描述创造的实体。
2.1 类的定义
类中主要包含两部分：
● 属性 property（成员变量 member value或 数据成员）
在类中存在的变量，用于存储数据，通常是一个名词，例如身高、价格、颜色......
● 行为（成员函数 member function）
可以执行的功能，是类中的函数，通常是一个动词或动词词组，例如：吃饭、运行、关闭......
成员 = 成员变量 + 成员函数
#include <iostream>
using namespace std;
/**
* @brief The MobilePhone class
* 手机类
*/
class MobilePhone // 帕斯卡（大驼峰）命名法：所有单词首字母大写
{
public: // 表示访问不受限
string brand; // 品牌
string model; // 型号
int weight; // 重量
void play_music()
{
cout << "Remedy" << endl;
}
void run_game()
{
cout << "炉石传说" << endl;
}
void communicate()
{
cout << "喂？" << endl;
}
};
2.2 创建对象
C++支持两种对象：
● 栈内存对象
在生命周期（生命周期为所在的{}）结束后，自动被回收，调用成员使用.
● 堆内存对象
必须使用new关键字创建对象，使用指针保存对象首地址，使用delete销毁对象，如果创建后没有手动销毁，对象会持续存在（内存泄漏），调用成员使用->（在Qt Creator中按.键自动转为->）
#include <iostream>
using namespace std;
class MobilePhone
{
public:
string brand;
string model;
int weight;
void play_music()
{
cout << "Remedy" << endl;
}
void run_game()
{
cout << "炉石传说" << endl;
}
void communicate()
{
cout << "喂？" << endl;
}
};
int main()
{
// 栈内存对象
MobilePhone mp1;
// 调用成员变量，先赋值，再读取输出
mp1.brand = "苹果";
mp1.model = "16 Pro Max";
mp1.weight = 200;
cout << mp1.brand << endl;
cout << mp1.model << endl;
cout << mp1.weight << endl;
// 调用成员函数
mp1.communicate();
mp1.play_music();
mp1.run_game();
// 堆内存对象
MobilePhone* mp2 = new MobilePhone;
mp2->brand = "华为";
mp2->model = "非凡大师xt1";
mp2->weight = 301;
cout << mp2->brand << endl;
cout << mp2->model << endl;
cout << mp2->weight << endl;
mp2->communicate();
mp2->play_music();
mp2->run_game();
delete mp2; // 销毁mp2
// 不要销毁后还使用
// cout << mp2->brand << endl;
// mp2->communicate();
return 0;
} // mp1销毁
三. 封装（重点）
上面的代码与结构体非常相似，因为结构体就是一种完全开放的类。类通常需要进行封装，封装指的是先将类的一些属性和细节隐藏，再重新提供外部调用接口。
#include <iostream>
using namespace std;
class MobilePhone
{
private: // 私有：被修饰的成员只能在类内访问
string brand; // 读写
string model = "16"; // 只读
int weight; // 只写
public:
string get_brand() // getter：读函数
{
return brand;
}
void set_brand(string b) // setter：写函数
{
brand = b;
}
string get_model()
{
return model;
}
void set_weight(int w)
{
weight = w;
}
};
int main()
{
MobilePhone mp1;
// 调用setter设置属性值
mp1.set_brand("华为");
mp1.set_weight(300);
// 调用getter获取属性值
cout << mp1.get_brand() << endl;
cout << mp1.get_model() << endl;
// TODO 可以试试堆内存对象
return 0;
}
封装的意义在于让程序员站在外部视角看待整个对象整体，忽略内部细节，同时可以提升代码的安全性和可维护性。
四. 构造函数 constructor（重点）
4.1 基础使用
类中有一种特殊的成员函数，在创建对象时必须调用，这个函数就是构造函数，构造函数的特殊性体现在：
● 不写返回值
● 函数名称必须是类名
● 如果程序员不手动编写构造函数，编译器会自动添加一个无参且函数体为空的构造函数。
构造函数经常用于在创建对象时进行对象属性初始化，构造函数也支持参数默认值和重载。
#include <iostream>
using namespace std;
class MobilePhone
{
private:
string brand;
string model;
int weight;
public:
// 编译器会在程序员不写的情况下添加下面的构造函数
// MobilePhone(){}
MobilePhone()
{
// 给属性赋予初始值
brand = "山寨";
model = "???";
weight = 188;
cout << "构造函数" << endl;
}
MobilePhone(string b,string m,int w)
{
brand = b;
model = m;
weight = w;
cout << "构造函数2" << endl;
}
/**
* @brief show 输出所有属性值
*/
void show()
{
cout << brand << endl;
cout << model << endl;
cout << weight << endl;
}
};
int main()
{
MobilePhone mp1;
mp1.show();
MobilePhone* mp2 = new MobilePhone;
mp2->show();
delete mp2;
MobilePhone mp3("魅族","Lucky08",199);
mp3.show();
MobilePhone* mp4 = new MobilePhone("小米","su7",2100000);
mp4->show();
delete mp4;
cout << "主函数结束" << endl;
return 0;
}
4.2 构造初始化列表
在当前阶段，下面的两种写法是等效。
4.3 构造函数的调用方式（掌握）
构造函数可以显式调用，也可以隐式调用。
显式调用：在创建对象时使用明确的构造函数调用语法，不能被explicit关键字影响。
隐式调用：在创建对象时不使用明确的构造函数调用语法，受到explicit关键字影响
#include <iostream>
using namespace std;
class Student
{
private:
string name;
public:
Student(string n):name(n)
{
cout << "构造函数，name=" << name << endl;
}
string get_name()
{
return name;
}
};
int main()
{
Student s1("张三");
cout << s1.get_name() << endl;
Student* s2 = new Student("李四");
cout << s2->get_name() << endl;
delete s2;
string name = "王五";
Student s3 = name; // 编译器帮忙调用了构造函数
cout << s3.get_name() << endl;
Student s4(name); // 编译器帮忙调用了构造函数
cout << s4.get_name() << endl;
return 0;
}
使用explicit关键字可以屏蔽隐式调用的构造函数。
#include <iostream>
using namespace std;
class Student
{
private:
string name;
public:
// 明确的
explicit Student(string n):name(n)
{
cout << "构造函数，name=" << name << endl;
}
string get_name()
{
return name;
}
};
int main()
{
Student s1("张三"); // 显式
cout << s1.get_name() << endl;
Student* s2 = new Student("李四"); // 显式
cout << s2->get_name() << endl;
delete s2;
string name = "王五";
// Student s3 = name; // 隐式，被explicit屏蔽
// cout << s3.get_name() << endl;
Student s4(name); // 显式
cout << s4.get_name() << endl;
return 0;
}
4.4 拷贝构造函数
4.4.1 概念
如果程序员不手动编写拷贝构造函数，编译器会为每个类增加一个拷贝构造函数。
通过拷贝构造函数创建的新对象，只是属性值与源对象相同，但是会在新的地址空间进行开辟。
#include <iostream>
using namespace std;
class Student
{
private:
string name;
public:
Student(string n):name(n)
{
cout << "构造函数，name=" << name << endl;
}
// 编译器自动添加的拷贝构造函数
// Student(const Student& s)
// {
// name = s.name;
// }
Student(const Student& s)
{
name = s.name;
cout << "拷贝构造函数" << endl;
}
string get_name()
{
cout << &name << endl;
return name;
}
};
int main()
{
Student s1("张三");
cout << s1.get_name() << endl;
Student s2(s1);
cout << s2.get_name() << endl;
return 0;
}
4.4.2浅拷贝
#include <iostream>
#include <string.h> // 头文件
using namespace std;
class Student
{
private:
char* name;
public:
Student(char* n):name(n)
{
cout << "构造函数" << endl;
}
char* get_name()
{
return name;
}
};
int main()
{
char name[20] = "张三";
Student s1(name);
Student s2(s1);
strcpy(name,"李四");
cout << s1.get_name() << endl; // 李四
cout << s2.get_name() << endl; // 李四
return 0;
}
在上面的代码中，在31行修改了26行的字符数组内容，s1和s2隐藏的成员变量的值就变了，且s1和s2的name保存的地址就是26行的name，这都不符合面向对象的特性。
4.4.3深拷贝
#include <iostream>
#include <string.h> // 头文件
using namespace std;
class Student
{
private:
char* name;
public:
Student(char* n):name(new char[20])
{
// 同步两块内存的内容
strcpy(name,n);
cout << "构造函数" << endl;
}
Student(const Student& s)
{
// 同步两块内存的内容
name = new char[20];
strcpy(name,s.name);
cout << "拷贝构造函数" << endl;
}
char* get_name()
{
return name;
}
};
int main()
{
char name[20] = "张三";
Student s1(name);
Student s2(s1);
strcpy(name,"李四");
cout << s1.get_name() << endl; // 张三
cout << s2.get_name() << endl; // 张三
return 0;
}
在上面的深拷贝代码中，new出来的空间并没有delete回收，因此会造成内存泄漏问题。
五. 析构函数 destructor（重点）
析构函数是与构造函数对立的函数，也是一种特殊的成员函数。
构造函数 |
析构函数 |
函数名称为类名 |
函数名称为~类名 |
功能为创建对象并初始化 |
功能为在对象销毁时回收资源 |
在创建对象时调用 |
在对象销毁时自动被调用 |
有参数，支持重载和默认值 |
无参数，不支持重载和默认值 |
程序员不手写析构函数，编译器也会添加一个下面格式的析构函数：
#include <iostream>
using namespace std;
class Dog
{
public:
~Dog()
{
cout << "析构函数" << endl;
}
};
int main()
{
Dog d1;
Dog* d2 = new Dog;
delete d2; // d2输出：析构函数
cout << "主函数结束" << endl;
return 0;
} // d1输出：析构函数
回到深拷贝代码中，可以在析构函数里释放堆内存资源，在Student中添加下面的代码：
