文章目录
一、容器思想
1、自定义类可拷贝 - 深拷贝与浅拷贝
上一篇博客 【C++】泛型编程 ⑬ ( 类模板示例 - 数组类模板 | 构造函数和析构函数 的 声明与实现 | 普通成员函数 的 声明与实现 | 外部友元函数 的 声明与实现 ) 中 , 实现了一个 数组 类模板 , 数组 中的 数据元素 是 泛型类型 , 可以是任意类型 ;
也就是说 , 该数组可以存储 任意类型 的数据 , 包括 自定义类对象 ;
该数组 就是一个 数据的容器 ;
数组中 每个元素 插入数据时 , 其本质是一个 拷贝操作 , 数组 的 内存空间 在 声明实际类型 以及 创建 时 , 就已经确定了 , 向数组中插入元素 , 就是将 已有的 数据 拷贝到 已经分配好的内存中 ;
向 数据容器 ( 数组 ) 中插入的数据 , 必须可以被 拷贝 , 如果 不能被拷贝 , 就会出现插入数据失败的问题 ;
容器 中的 类型 可拷贝 , 就是要求 容器中的 数据类型 都是 值语义 , 不是 引用语义 ,
向 容器 中插入元素 , 就是拷贝 数据内容 到容器中 , 要将真实的值拷贝进去 , 不是将 引用地址 拷贝进去 ,
就是 深拷贝 和 浅拷贝 的问题 ;
下面的示例中 , 自定义类中的成员变量 char m_name[32] 是 在定义时 , 直接分配好的 ,
如果 自定义类 中有 指针类型的成员变量 , 如 char* m_name , 涉及到 动态分配内存 , 如果没有定义 拷贝构造函数 , 默认的 拷贝构造函数 是 浅拷贝 函数 , 直接将 指针地址 简单拷贝 , 这就是 不可被拷贝的情况 ;
那么多个 数组元素 就会共享 相同的 堆内存 数据 , 此时就会出现问题 ;
如果遇到了上述问题 , 定义了 char* m_name 成员变量 , 涉及到 动态分配内存 , 那么 该自定义类 必须自己实现 深拷贝 的 拷贝构造函数 ;
编写的类 , 可以存储到 数组类模板 容器 中 , 那么 该类 必须 支持 拷贝工作 , 具体一些就是 深拷贝 工作 ;
2、自定义类可拷贝 - 代码示例
下面简单实现一个类 , 该类中维护了 2 个成员变量 , char m_name[32] 数组变量 和 int m_age 变量 , 这两个 成员 都是在 创建时 就会分配内存空间 , 不存在 深拷贝问题 ;
如果 char m_name[32] 数组变量 改为 char* m_name 指针变量 , 就需要考虑 深拷贝问题了 ;
class Student
{
public:
Student(){
m_age = 10;
strcpy(m_name, "NULL");
}
Student(const char* name, int age) {
strcpy(this->m_name, name);
this->m_age = age;
}
void printT() {
cout << "name : " << m_name << " , age : " << m_age << endl;
}
private:
char m_name[32];
int m_age;
};
3、自定义类可打印 - 左移运算符重载
数组类模板 中 , 实现了 左移运算符 打印日志 , 如果 数组中 存储 自定义类对象 想要通过 cout 打印出来 , 那么 该自定义类 必须 进行 左移运算符重载操作 ;
声明 左移运算符重载函数 :
class Student
{
friend ostream& operator<<(ostream& out, const Student& s);
}
实现 左移运算符重载函数 :
// 重载左移运算符实现
ostream& operator<<(ostream& out, const Student& s) {
out << "name : " << s.m_name << " , age : " << s.m_age << " ; ";
return out;
}
二、代码示例
1、Array.h 头文件
#pragma once
#include "iostream"
using namespace std;
template <typename T>
class Array
{
// 左移 << 操作符重载
// 注意 声明时 , 需要在 函数名 和 参数列表之间 注明 泛型类型 <T>
// 实现时 , 不能在 函数名 和 参数列表之间 注明 泛型类型 <T>
friend ostream& operator<< <T> (ostream& out, const Array& a);
public:
// 有参构造函数
Array(int len = 0);
// 拷贝构造函数
Array(const Array& array);
// 析构函数
~Array();
public:
// 数组下标 [] 操作符重载
// 数组元素类型是 T 类型
T& operator[](int i);
// 等号 = 操作符重载
Array& operator=(const Array& a);
private:
// 数组长度
int m_length;
// 指向数组数据内存 的指针
// 指针类型 是 泛型类型 T
T* m_space;
};
2、Array.cpp 代码文件
#include "Array.h"
// 左移 << 操作符重载
// 注意 声明时 , 需要在 函数名 和 参数列表之间 注明 泛型类型 <T>
// 实现时 , 不能在 函数名 和 参数列表之间 注明 泛型类型 <T>
template <typename T>
ostream& operator<< (ostream& out, const Array<T>& a)
{
for (int i = 0; i < a.m_length; i++)
{
// 在一行内输入数据, 使用空格隔开, 不换行
out << a.m_space[i] << " ";
}
// 换行
out << endl;
return out;
}
// 有参构造函数
template <typename T>
Array<T>::Array(int len)
{
// 设置数组长度
m_length = len;
// 为数组在堆内存中分配内存
// 注意 元素类型为 T
m_space = new T[m_length];
cout << " 调用有参构造函数 " << endl;
}
// 拷贝构造函数
// 这是一个深拷贝 拷贝构造函数
template <typename T>
Array<T>::Array(const Array<T>& array)
{
// 设置数组长度
m_length = array.m_length;
// 创建数组
// 注意 元素类型为 T
m_space = new T[m_length];
// 为数组赋值
for (int i = 0; i < m_length; i++)
{
m_space[i] = array.m_space[i];
}
cout << " 调用拷贝构造函数 " << endl;
}
// 析构函数
template <typename T>
Array<T>::~Array()
{
if (m_space != NULL)
{
// 释放 new T[m_length] 分配的内存
delete[] m_space;
m_space = NULL;
m_length = 0;
}
cout << " 调用析构函数 " << endl;
}
// 数组下标 [] 操作符重载
template <typename T>
T& Array<T>::operator[](int i)
{
return m_space[i];
}
// 等号 = 操作符重载
template <typename T>
Array<T>& Array<T>::operator=(const Array<T>& a)
{
if (this->m_space != NULL)
{
// 释放 new int[m_length] 分配的内存
delete[] this->m_space;
this->m_space = NULL;
}
// 设置数组长度
this->m_length = a.m_length;
// 创建数组
this->m_space = new T[m_length];
// 为数组赋值
for (int i = 0; i < m_length; i++)
{
this->m_space[i] = a.m_space[i];
}
cout << " 调用 等号 = 操作符重载 函数" << endl;
// 返回是引用类型
// 返回引用就是返回本身
// 将 this 指针解引用, 即可获取数组本身
return *this;
}
3、Test.cpp 主函数代码文件
#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
using namespace std;
// 此处注意, 类模板 声明与实现 分开编写
// 由于有 二次编译 导致 导入 .h 头文件 类模板函数声明 无法找到 函数实现
// 必须 导入 cpp 文件
#include "Array.cpp"
class Student
{
friend ostream& operator<<(ostream& out, const Student& s);
public:
Student(){
m_age = 10;
strcpy(m_name, "NULL");
}
Student(const char* name, int age) {
strcpy(this->m_name, name);
this->m_age = age;
}
void printT() {
cout << "name : " << m_name << " , age : " << m_age << endl;
}
private:
char m_name[32];
int m_age;
};
// 重载左移运算符实现
ostream& operator<<(ostream& out, const Student& s) {
out << "name : " << s.m_name << " , age : " << s.m_age << " ; ";
return out;
}
int main() {
// 验证 有参构造函数
Array<Student> array(3);
Student s0("Tom", 18), s1("Jerry", 12), s2("Jack", 16);
array[0] = s0;
array[1] = s1;
array[2] = s2;
// 遍历数组 打印数组元素
for (int i = 0; i < 3; i++) {
array[i].printT();
}
cout << array << endl;
// 控制台暂停 , 按任意键继续向后执行
system("pause");
return 0;
}
4、执行结果
执行结果 :
调用有参构造函数
name : Tom , age : 18
name : Jerry , age : 12
name : Jack , age : 16
name : Tom , age : 18 ; name : Jerry , age : 12 ; name : Jack , age : 16 ;
Press any key to continue . . .