自定义Array,vector
《老九学堂C++课程》《C++ primer》学习笔记。《老九学堂C++课程》详情请到B站搜索《老九零基础学编程C++入门》
-------------简单的事情重复做,重复的事情用心做,用心的事情坚持做(老九君)---------------
1.自定义Array
//main.cpp
#include <iostream>
#include "Array.h"
using namespace std;
void TestArray(){
Array arr1(10);
cout << arr1;
arr1[0] = 1234;
cout << arr1;
}
int main() {
//TestIntefer();
//TestString();
TestArray();
return 0;
}
//Array.h
//
// Created by 陈莹莹 on 2021/3/5.
//
#ifndef CHAPTER12_ARRAY_H
#define CHAPTER12_ARRAY_H
#include <iostream>
using namespace std;
class Array {
public:
Array(int lenght = 0);
// 拷贝构造函数
Array(const Array & arr);
// 赋值运算符重载
const Array & operator=(const Array & arr);
// 重载输出运算符
friend ostream & operator<<(ostream & out, const Array & arr);
// 重载[],实现下标索引和下标赋值
// int operator[](int index); // 获取元素,无法写入,这个编译器只有返回值不同是不能够重载的
int & operator[](int index); // 可以修改了
~Array();
private:
int m_lenght;
int *m_data; // 需要加啥?
};
#endif //CHAPTER12_ARRAY_H
//Array.cpp
//
// Created by 陈莹莹 on 2021/3/5.
//
#include <iostream>
#include <cstring>
#include "Array.h"
using namespace std;
Array::Array(int lenght):m_lenght(lenght)
{
if(m_lenght == 0){
m_data = NULL;
}
else{
m_data = new int[m_lenght];
}
}
Array::Array(const Array & arr){
if(arr.m_lenght == 0){
return;
}
m_lenght = arr.m_lenght;
m_data = new int[m_lenght];
memcpy(m_data, arr.m_data, m_lenght*sizeof(int));
}
const Array & Array::operator=(const Array & arr){
if(this == &arr){
return *this;
}
m_lenght = arr.m_lenght;
m_data = new int[m_lenght];
memcpy(m_data, arr.m_data, m_lenght*sizeof(int));
return *this;
}
ostream & operator<<(ostream & out, const Array & arr){
for(int i = 0; i < arr.m_lenght; i++){
out << arr.m_data[i] << ";";
}
out << endl;
return out;
}
//int Array::operator[](int index) {
// if(m_lenght==0){
// cerr << "数组为空,访问失败!" << endl;
// }
// if(index < 0 || index >= m_lenght){
// cerr << "数组下标越界!" << endl;
// }
// return m_data[index];
//}
int & Array::operator[](int index) {
if(m_lenght==0){
cerr << "数组为空,访问失败!" << endl;
}
if(index < 0 || index >= m_lenght){
cerr << "数组下标越界!" << endl;
}
return m_data[index];
}
Array::~Array()
{
delete[] m_data;
}
2.自定义vector
模版技术来实现
//main.cpp
#include <iostream>
#include "MyVector.h"
using namespace std;
void TestVector(){
MyVector<int> vec1; // 默认构造
MyVector<double> vec2(10,99.9);
cout << "vec1" << vec1 << endl;
cout << "vec2" << vec2 << endl;
MyVector<string> vec3(5, string("abc"));
cout << "vec3" << vec3 << endl;
// vec3.push_back("123");
// cout << "vec3" << vec3 << endl; // 没成功
}
int main() {
//TestIntefer();
//TestString();
//TestArray();
TestVector();
return 0;
}
//Vector.h
//
// Created by 陈莹莹 on 2021/3/8.
// 自定义的容器类
// 使用的模版技术,一般用来做算法,比如重载100次某个类型的算法
// 如果使用模版技术,那么类的声明和方法实现都要放在同一个头文件中
int GetMax(int num1, int num2);
double GetMax(double num1, double num2);
// 写起来太麻烦了,需要使用模版技术来简化一下
//tempalte<typename T1> 提示要建立心的T模版类
//T1 GetMax1(T1 num1, T1 num2);
#ifndef CHAPTER12_MYVECTOR_H
#define CHAPTER12_MYVECTOR_H
#include <iostream>
#include <cstring>
using namespace std;
//template<class T> // 声明了一个模版,之后这个T可以指代所有的东西(类型)
template<typename T> // 新版本的C++的写法
class MyVector {
public:
MyVector();
MyVector(int len, T element); // 填充len长度的元素element
MyVector(const MyVector<T> & vec); // Myvector<T>是这个类的类型,复制构造函数
MyVector<T> & operator=(const MyVector<T> & vec);
T & operator[](int index);
void push_back(T element); // 将元素element 添加到内部数组中
T pop_back(); // 返回并删除最后一个元素
void insert(int pos, T element); // 在pos位置处,插入元素element
void clear(); //清空所有的元素
template<class T2>
friend ostream & operator<<(ostream & out, const MyVector<T2> & vec);
~MyVector();
private:
T * m_elements; // 用来存放元素的数组
int m_length; // 所存放的实际个数
int m_capacity; // 当前元素数组的大小
};
template<typename T>
MyVector<T>::MyVector():m_capacity(16), m_length(0)
{
this->m_elements = new T[m_capacity];
}
template<typename T>
MyVector<T>::MyVector(int len, T element):m_capacity(16)
{
m_capacity = len + m_capacity;
m_length = len;
m_elements= new T[m_capacity];
// 使用for 循环复制
for(int i = 0 ; i < m_capacity; i++){
//m_element[i] = elemnet; // 注意:这里每次都会调用重载的赋值运算符
memcpy(&m_elements[i], &element, sizeof(T)); // 不用重载复制运算符
}
}
template<typename T>
MyVector<T>::MyVector(const MyVector<T> &vec)
{
m_capacity = vec.m_capacity;
m_length = vec.m_length;
m_elements = new T[m_capacity];
memcpy(m_elements, vec.m_elements, m_length * sizeof(T));
}
template<typename T>
MyVector<T> & MyVector<T>::operator=(const MyVector<T> & vec)
{
if(this == vec) return *this;
if(NULL != m_elements){ // 删除原来的指针,产生新的指针
delete[] m_elements;
m_elements = NULL;
}
m_capacity = vec.m_length + vec.m_capacity;
m_length = vec.m_length;
m_elements= new T[vec.m_capacity];
memcpy(m_elements, vec.m_elements, m_length * sizeof(T));
return *this;
}
template<typename T>
T & MyVector<T>::operator[](int index) {
return m_elements[index];
}
template<typename T>
void MyVector<T>::push_back(T element)
{
if(NULL == m_elements){
m_capacity = 16;
m_length = 0;
m_elements = new T[m_capacity];
}
// 判断当前的数组容量是否已满
if(m_length == m_capacity){
// 如果满了,就扩容:当前容量*2+1
T * newElements = new T[m_capacity * 2 + 1];
// 把原来的元素拷贝到新空间中
memcpy(newElements, m_elements, m_length * sizeof(T));
delete[] m_elements;
m_elements = newElements; // 指向新空间
}
// m_elements[m_length] = element; 要重载=
memcpy(m_elements[m_length++], &element, sizeof(T));
}
template<class T2>
ostream & operator<<(ostream & out, const MyVector<T2> & vec)
{
for(int i = 0; i < vec.m_length; i++){
out << vec.m_elements[i] << "; ";
}
out << endl;
return out;
}
template<typename T>
MyVector<T>::~MyVector()
{
delete[] m_elements;
}
#endif //CHAPTER12_MYVECTOR_H