#include <iostream>
#include <string>
//
// main.cpp
// Xcode/Cplusplus
//
// Created by zforw on 2021/3/2.
//
#include <iostream>
#include <algorithm>
using namespace std;
template <typename Type>
class VLA {
public:
/*空参构造*/
VLA() {
_size = 0;
elem = nullptr;
}
/* int capacity=10;//初始容量为10 */
/* Type *elem[capacity];指针数组 */
// construct with n elements of val.
VLA(Type val, int n) {
/*Type形参使用引用或者右值,避免不必要的拷贝*/
_size = n;
elem = new Type[n];
for (int i = 0; i < n; i++) {
elem[i] = val;
}
}
// Initialize using an array
VLA(const Type V[], int len) {
/*Type形参使用引用或者右值,避免不必要的拷贝*/
_size = len;
elem = new Type[len];
for (int i = 0; i < len; i++) {
elem[i] = V[i];
}
}
VLA(const VLA<Type>& copy) {
_size = copy._size;
elem = new int[copy._size];
for (int i = 0; i < _size; ++i) {
elem[i] = copy.elem[i];
}
}
~VLA() {
delete[] elem;
elem = nullptr;
}
void push_back(Type val) { insert(val, _size); };// insert at the end
void insert(Type, int); // intsert the element at a position
void del(int); // delete the element at a position
void pop() { del(_size - 1); }; // pop up the last element
int findKey(Type) const; // find the element given by order
void Sort();
int size() const; // return the _size
VLA<Type>& operator =(const VLA<Type>& b) {
if (this != &b) {
if (_size) delete[] elem;
elem = new Type[b._size];
for (int i = 0; i < b._size; ++i) {
elem[i] = b.elem[i];
}
}
return *this;
// return the reference of current object
// to make sure chained assignment a = b = c
};
Type operator [](int index) const {
return elem[index];
};
//bool operator <(Type b) {}
private:
Type* elem; // restore the elements of Type
int _size; // numbers of elem
};
/*应当改名为:
Type** myElem; 或Type *myelem[capacity]; 前者为二级指针后者为指针数组
int mySize;
or
Type** m_Elem;或Type *m_elem[capacity]; 前者为二级指针后者为指针数组
int m_Size;
为什么使用指针数组(二级指针):
使用普通的数组,无法保存对象,必须使用指针数组才可以保存对象。而且存储指针的话,在数组的拷贝时,可以直将指针指向原数组,
不必对对象中的数据进行拷贝,更加高效,且部分对象没有拷贝函数,直接复制会出错。
为什么改名:
变量应当遵守命名规范,规范的命名可以让其他人快速熟悉你写的代码,详细的命名规则,可以参看各家大厂的书面文件。
*/
template <typename Type>
void VLA<Type>::insert(Type val, int pos) {
/*这个传入应该使用引用或者右值,防止拷贝*/
/*判断pos是否在合理范围*/
/*临时变量应该用t_Elem或tElem*/
Type* _elem = elem; //restore the original data
elem = new Type[++_size]; //allocate a new pointer
for (int i = 0; i < pos; ++i) {
elem[i] = _elem[i];//copy the orijginal data from 0 to pos - 1
}
/*这种插入仅仅适用于基本变量,如果Type是对象就会出错。所以应当使用指针数组。*/
elem[pos] = val; // set the value
for (int i = pos + 1; i < _size; ++i) {
elem[i] = _elem[i - 1];//copy the remaining values
}
delete[] _elem;// free the memory
/*无用的赋值,在变量明确弃用的时候,不需要为指针写入nullptr*/
_elem = nullptr;
}
template <typename Type>
void VLA<Type>::del(int pos) {
if (pos < 0 || pos >= _size)
return;
for (int i = pos; i < _size; ++i) {
elem[i] = elem[i + 1];
}
_size--;
/*删除不需要重新分配空间*/
Type* _elem = elem;
elem = new Type[_size];
for (int i = 0; i < _size; ++i) {
elem[i] = _elem[i];
}
delete[] _elem;
_elem = nullptr;
}
template <typename Type>
int VLA<Type>::findKey(Type k) const {
/*这个形参应该使用引用,防止拷贝*/
for (int i = 0; i < _size; ++i) {
if (elem[i] == k)
return i;
}
return -1; // not found
}
template <typename Type>
void VLA<Type>::Sort() {
sort(elem, elem + _size); // using STL
}
template <typename Type>
int VLA<Type>::size() const {
return _size;
}
int main() {
int b[] = { 1, 2, 3 };
VLA<int> c(b, 3);
VLA<int> a(0, 1);
for (int i = 10; i >= 1; --i) {
a.push_back(i);
}
a.push_back(11);
for (int i = 0; i < a.size(); ++i) {
cout << a[i] << " ";
}
cout << endl;
a.pop();
for (int i = 0; i < a.size(); ++i) {
cout << a[i] << " ";
}
cout << endl;
a.Sort();
for (int i = 0; i < a.size(); ++i) {
cout << a[i] << " ";
}
return 0;
}
/*
* 总结:
* 1、存储请使用指针数组,否则无法存储对象。
* 2、形参请尽可能使用引用或者右值,防止不必要的拷贝,在C++中,对对象进行无效的拷贝是愚蠢的。
* 3、删除不需要重新分配空间,仅仅把末尾的标志指针往左移动一位就行。
* 4、扩容可以使用翻倍扩容的方法,即每次扩容都是翻倍,删除则不重新分配空间。(这样就需要增加一个变量:capacity 数组的容量上限)
* 5、命名需要规范,比如对象的属性请使用带有my或m_前缀的标志,临时变量请使用带有t或者t_前缀的。
*
*
*/
【参考】邓俊辉.数据结构与算法:C++语言版第三版[M].清华大学出版社, 2013-9.