STL-lesson001_1_模板实现Array类

/*MyString.h*/

#ifndef _MYSTRING_H_
#define _MYSTRING_H_
#define _CRT_SECURE_NO_WARNINGS
#include <cstring>
#include <limits>
#include <string>

namespace PoEdu
{
class CMyString
{
public:
// constructor
CMyString();
CMyString(const CMyString &other);
CMyString(const CMyString &other, size_t pos, size_t len = nopos_);
CMyString(const char *str);
CMyString(const char *str, size_t len);
CMyString(size_t len, char c);
CMyString(const char *first, const char *last);

// operator=
CMyString& operator= (const CMyString &other);
CMyString& operator= (const char* str);
CMyString& operator= (char c);

// deconstructor
~CMyString();

// similar to iterator
char *Begin() const;
char *End() const;
char *Rbegin() const;
char *REnd() const;

// capcity
size_t Size() const;
size_t Length() const;
size_t Max_size() const;
void Resize(size_t len);
void Resize(size_t len, char c);
size_t Capacity() const;
void Reserve(size_t len);
void Clear();
bool Empty() const;

// Element access:
char& operator[] (size_t index);
const char& operator[] (size_t index) const;
char& At(size_t index);
const char& At(size_t index) const;

// Modifiers:
CMyString& operator+= (const CMyString &otehr);
CMyString& operator+= (const char *str);
CMyString& operator+= (char c);
CMyString& Append(const CMyString& other);
CMyString& Append(const CMyString& other, size_t subpos, size_t sublen);
CMyString& Append(const char* str);
CMyString& Append(const char* str, size_t len);
CMyString& Append(size_t len, char c);
void Push_back(char c);
CMyString& Assign(const CMyString& other);
CMyString& Assign(const CMyString& other, size_t subpos, size_t sublen);
CMyString& Assign(const char* str);
CMyString& Assign(const char* str, size_t len);
CMyString& Assign(size_t len, char c);
CMyString& Insert(size_t pos, const CMyString& other);
CMyString& Insert(size_t pos, const CMyString& other, size_t subpos, size_t sublen);
CMyString& Insert(size_t pos, const char* str);
CMyString& Insert(size_t pos, const char* str, size_t len);
CMyString& Insert(size_t pos, size_t len, char c);
CMyString& Erase(size_t pos = 0, size_t len = nopos_);

void Swap(CMyString& other);

// Non-member function overloads
friend CMyString operator+(const CMyString &lhs, const CMyString &rhs);
friend CMyString operator+(const CMyString &lhs, const char *rhs);
friend CMyString operator+(const char *lhs, const CMyString& rhs);
friend CMyString operator+(const CMyString &lhs, char rhs);
friend CMyString operator+(char lhs, const CMyString &rhs);
friend std::ostream &operator<<(std::ostream &os, const CMyString &other);

// String operations :
const char* C_str() const;

private:
char *Alloc(const char *str);

public:
static const size_t nopos_ = -1;

private:
char *str_;
size_t length_;         // 当前长度
size_t capacity_;       // 当前容量，可以每次增加16个     stl中的逻辑是每次分配16个字节空间，只不过最后一个字节是用来保存\0的
const size_t max_size_; // 最大长度
};
}

#endif // !_MYSTRING_H_

/*MyString.cpp*/

#include "MyString.h"
#include <iostream>

namespace PoEdu
{
CMyString::CMyString() : max_size_(UINT_MAX-1)
{
str_ = Alloc("");
}

CMyString::CMyString(const char *str) : max_size_(UINT_MAX-1)
{
str_ = Alloc(str);
}

CMyString::CMyString(const CMyString& other) : max_size_(UINT_MAX-1)
{
str_ = Alloc(other.str_);
}

CMyString::CMyString(const CMyString& other, size_t pos, size_t len) : max_size_(UINT_MAX-1)
{
if (len > other.length_)
length_ = other.length_ - pos;
else
length_ = len - pos;
str_ = new char[length_ + sizeof(char)];
memset(str_, 0, length_ + sizeof(char));

for (size_t index=0; index < length_; ++index)
{
str_[index] = other.str_[index + pos];
}
}

CMyString::CMyString(const char* str, size_t len) : max_size_(UINT_MAX-1)
{
size_t curlen = strlen(str);
length_ = len;
str_ = new char[length_ + sizeof(char)];
memset(str_, 0, length_ + sizeof(char));

for (size_t index = 0; index < length_ && index < curlen; ++index)
{
str_[index] = str[index];
}

if (length_ > len)
str_[len] = '\0';
else
str_[length_] = '\0';
}

CMyString::CMyString(size_t len, char c) : max_size_(UINT_MAX-1)
{
length_ = len;
str_ = new char[length_ + sizeof(char)];
memset(str_, 0, length_ + sizeof(char));
for (size_t index = 0; index < length_; ++index)
{
str_[index] = c;
}
}

CMyString::CMyString(const char* first, const char* last) : max_size_(UINT_MAX-1)
{
length_ = last - first;
str_ = new char[length_ + sizeof(char)];
memset(str_, 0, length_ + sizeof(char));
memcpy(str_, first, length_);
}

CMyString& CMyString::operator=(const CMyString& other)
{
if (this != &other)
{
delete[] str_;
str_ = Alloc(other.str_);
}

return *this;
}

CMyString& CMyString::operator=(const char* str)
{
delete[] str_;
str_ = Alloc(str);
return *this;
}

CMyString& CMyString::operator=(char c)
{
delete[] str_;
length_ = 1;
str_ = new char[length_ + 1];
memset(str_, 0, length_ + sizeof(char));
str_[0] = c;
return *this;
}

CMyString::~CMyString()
{
delete[] str_;
}

char* CMyString::Begin() const
{
return str_;
}

char* CMyString::End() const
{
return &(str_[length_ + 1]);    // 返回的是一个未维护的地址
}

char* CMyString::Rbegin() const
{
return End();
}

char* CMyString::REnd() const
{
return Begin();
}

size_t CMyString::Size() const
{
return length_;
}

size_t CMyString::Length() const
{
return length_;
}

size_t CMyString::Capacity() const
{
return capacity_;
}

void CMyString::Reserve(size_t len)
{
if (len > capacity_)
{
while (capacity_ < len)
{
capacity_ += 16;
}

char *temp = new char[capacity_ + sizeof(char)];
memset(temp, 0, capacity_ + sizeof(char));
strcpy(temp, str_);
delete str_;
str_ = temp;
}
}

// 用非const版本调用const版本
// 问题！！！下面的两种实现有什么区别呢？貌似在使用上是一样的
char& CMyString::operator[](size_t index)
{
return const_cast<char &>(const_cast<const CMyString &>(*this)[index]);
}

const char& CMyString::operator[](size_t index) const
{
return str_[index];
}

char & CMyString::At(size_t index)
{
return const_cast<char &>(static_cast<const CMyString &>(*this).At(index));
}

const char & CMyString::At(size_t index) const
{
int temp = index;
if (index >= length_)
{
std::cout << "超出范围" << std::endl;
temp = length_ - 1;
}

return str_[temp];
}

CMyString & CMyString::operator+=(const CMyString & other)
{
return operator+=(other.str_);
}

CMyString & CMyString::operator+=(const char * str)
{
length_ += strlen(str);

while (capacity_ < length_)
{
capacity_ += 16;
}

char *temp = new char[capacity_ + sizeof(char)];
memset(temp, 0, capacity_ + sizeof(char));
strcpy(temp, str_);
strcat(temp, str);
delete[] str_;
str_ = temp;

return *this;
}

CMyString & CMyString::operator+=(char c)
{
char temp[2] = { 0 };
temp[0] = c;
return operator+=(temp);
}

CMyString & CMyString::Append(const CMyString & other)
{
*this += other;
return *this;
}

CMyString & CMyString::Append(const CMyString &other, size_t subpos, size_t sublen)
{
for (size_t index = subpos; index<subpos+sublen; ++index)
{
*this += other[index];
}

return *this;
}

CMyString & CMyString::Append(const char *str)
{
*this += str;
return *this;
}

CMyString & CMyString::Append(const char *str, size_t len)
{
for (size_t index=0; index<len; ++index)
{
*this += str[index];
}

return *this;
}

CMyString & CMyString::Append(size_t len, char c)
{
for (size_t index=0; index<len; ++index)
{
*this += c;
}

return *this;
}

void CMyString::Push_back(char c)
{
*this += c;
}

CMyString & CMyString::Assign(const CMyString & other)
{
(*this).Clear();
*this += other;
return *this;
}

CMyString & CMyString::Assign(const CMyString & other, size_t subpos, size_t sublen)
{
(*this).Clear();
(*this).Append(other, subpos, sublen);
return *this;
}

CMyString & CMyString::Assign(const char * str)
{
(*this).Clear();
*this += str;
return *this;
}

CMyString & CMyString::Assign(const char * str, size_t len)
{
(*this).Clear();
(*this).Append(str, len);
return *this;
}

CMyString & CMyString::Assign(size_t len, char c)
{
(*this).Clear();
(*this).Append(len, c);
return *this;
}

CMyString & CMyString::Insert(size_t pos, const CMyString & other)
{
length_ += other.length_;

while (capacity_ < length_)
{
capacity_ += 16;
}

char *temp = new char[capacity_ + sizeof(char)];
memset(temp, 0, capacity_ + sizeof(char));
memcpy(temp, str_, pos);
strcat(temp, other.C_str());
strcat(temp, &(str_[pos]));
delete[] str_;
str_ = temp;

return *this;
}

CMyString & CMyString::Insert(size_t pos, const CMyString & other, size_t subpos, size_t sublen)
{
length_ += sublen;

while (capacity_ < length_)
{
capacity_ += 16;
}

char *temp = new char[capacity_ + sizeof(char)];
memset(temp, 0, capacity_ + sizeof(char));
memcpy(temp, str_, pos);
memcpy(&temp[pos], &other[subpos], sublen);
strcat(temp, &str_[pos]);
delete[] str_;
str_ = temp;

return *this;
}

CMyString & CMyString::Insert(size_t pos, const char * str)
{
CMyString temp(str);
(*this).Insert(pos, temp);
return *this;
}

CMyString & CMyString::Insert(size_t pos, const char * str, size_t len)
{
CMyString temp(str, len);
(*this).Insert(pos, temp);
return *this;
}

CMyString & CMyString::Insert(size_t pos, size_t len, char c)
{
CMyString temp(len, c);
(*this).Insert(pos, temp);
return *this;
}

CMyString & CMyString::Erase(size_t pos, size_t len)
{
char *temp = new char[capacity_ + sizeof(char)];
memset(temp, 0, capacity_ + sizeof(char));

if (len < length_-pos)
{
memcpy(temp, str_, pos);
strcat(temp, &str_[pos + len]);
}
else
{
memcpy(temp, str_, pos);
}
delete[] str_;
str_ = temp;

return *this;
}

void CMyString::Swap(CMyString & other)
{
CMyString temp(other);
other = *this;
*this = temp;
}

size_t CMyString::Max_size() const
{
return max_size_;
}

void CMyString::Resize(size_t len)
{
bool bCopyAll = false;

if (length_ < len)
bCopyAll = true;
length_ = len;
char *temp = new char[length_ + sizeof(char)];
memset(temp, 0, length_ + sizeof(char));
if (bCopyAll)
{
strcpy(temp, str_);
}
else
{
for (size_t index = 0; index < length_; ++index)
{
temp[index] = str_[index];
}
}
delete[] str_;
str_ = temp;
}

void CMyString::Resize(size_t len, char c)
{
size_t length = length_;
Resize(len);
for (; length < length_; ++length)
{
str_[length] = c;
}
}

void CMyString::Clear()
{
length_ = 0;
delete[] str_;
str_ = new char[sizeof(char)];
str_[0] = '\0';
}

bool CMyString::Empty() const
{
return !length_;
}

const char * CMyString::C_str() const
{
return str_;
}

char* CMyString::Alloc(const char* str)
{
capacity_ = 15;
length_ = strlen(str);
while (capacity_ < length_)
{
capacity_ += 16;
}
char *temp = new char[capacity_ + sizeof(char)];
memset(temp, 0, capacity_ + sizeof(char));
strcpy(temp, str);

return temp;
}

std::ostream& operator<<(std::ostream& os, const CMyString& other)
{
for (size_t index = 0; index < other.length_; ++index)
{
std::cout << other.str_[index];
}

return os;
}

// 在写二元运算符的时候，都使用友元函数来实现，因为这样共明确，并没有隐藏第一个对象
CMyString operator+(const CMyString &lhs, const CMyString &rhs)
{
return (CMyString(lhs) += rhs);
}
CMyString operator+(const CMyString &lhs, const char *rhs)
{
return (CMyString(lhs) += rhs);
}
CMyString operator+(const char *lhs, const CMyString &rhs)
{
return (CMyString(lhs) += rhs);
}
CMyString operator+(const CMyString &lhs, char rhs)
{
return (CMyString(lhs) += rhs);
}
CMyString operator+(char lhs, const CMyString &rhs)
{
CMyString temp;
temp = lhs;
temp += rhs;
return temp;
}
}

MyArray类

/*MyArray.h*/

#ifndef _MYARRAY_H_
#define _MYARRAY_H_
#include <cstddef>
#include <limits>
#include <iostream>

namespace PoEdu
{
template<typename T>
class CMyArray
{
public:
// Member functions
CMyArray();
CMyArray(const CMyArray &other);
CMyArray(size_t n, const T &val);
CMyArray(const T *first, const T *last);
CMyArray &operator=(const CMyArray &other);
~CMyArray();

// Iterators:
T *Begin() const;
T *End() const;
T *Rbegin() const;
T *Rend() const;

// Capacity:
size_t Size() const;
size_t Max_size() const;
void Resize(size_t len, T str);
size_t Capacity() const;
bool Empty() const;
void Reserve(size_t len);

// Element access:
T &operator[](size_t index);
const T &operator[](size_t index) const;
T &At(size_t index);
const T &At(size_t index) const;
T &Front();
const T &Front() const;
T &Back();
const T &Back() const;

// Modifiers:
void Assign(size_t len, const T& other);
void Push_back(const T &val);
void Pop_back();
void Insert(size_t pos, size_t len, const T &other);
T *Erase(size_t pos);
T *Erase(size_t first, size_t last);
void Swap(CMyArray &other);
void Clear();

private:
T *data_;
size_t size_;
// 加上默认分配一定空间大小的变量
size_t capacity_;
const size_t max_size_;
};

template<typename T>
CMyArray<T>::CMyArray() : max_size_(UINT_MAX / 4)
{
size_ = 0;
capacity_ = 5;
data_ = new T[capacity_];
}
template<typename T>
inline CMyArray<T>::CMyArray(const CMyArray & other)
{
if (&other != this)
{
size_ = other.size_;
capacity_ = other.capacity_;
data_ = new T[capacity_];
for (size_t i = 0; i < size_; ++i)
{
data_[i] = other.data_[i];
}
}
}
template<typename T>
CMyArray<T>::CMyArray(size_t n, const T & val) : max_size_(UINT_MAX / 4)
{
size_ = n;
capacity_ = 5;
while (capacity_ < size_)
{
capacity_ *= 2;
}
data_ = new T[size_];
for (size_t i = 0; i < size_; ++i)
{
data_[i] = val; // 等号一定是提升出来的
}
}
template<typename T>
CMyArray<T>::CMyArray(const T * first, const T * last) : max_size_(UINT_MAX / 4)
{
size_ = (last - first) / sizeof(T);
data_ = new T[capacity_];
T *pAddr = const_cast<T *>(first);

for (size_t i = 0; i < size_; ++i)
{
data_[i] = *pAddr;
pAddr += sizeof(T);
}
}
template<typename T>
CMyArray<T> & CMyArray<T>::operator=(const CMyArray & other)
{
if (&other != this)
{
delete[] data_;
size_ = other.size_;
capacity_ = other.capacity_;
data_ = new T[capacity_];
for (size_t i = 0; i < size_; ++i)
{
data_[i] = other.data_[i];
}
}

return *this;
}
template<typename T>
CMyArray<T>::~CMyArray()
{
delete[] data_;
}
template<typename T>
T * CMyArray<T>::Begin() const
{
return data_;
}
template<typename T>
T * CMyArray<T>::End() const
{
return &(data_[size_]);
}
template<typename T>
T * CMyArray<T>::Rbegin() const
{
return End();
}
template<typename T>
T * CMyArray<T>::Rend() const
{
return Begin();
}
template<typename T>
size_t CMyArray<T>::Size() const
{
return size_;
}
template<typename T>
size_t CMyArray<T>::Max_size() const
{
return size_;
}
template<typename T>
void CMyArray<T>::Resize(size_t len, T str)
{
if (len < size_)
{
// 销毁后面的几个元素
for (size_t index = size_ - 1; index >= len; --index)
{
Pop_back();
}
}
else
{
// 以str来填充后面的元素
for (size_t index = size_; index < len; ++index)
{
Push_back(str);
}
}
}
template<typename T>
size_t CMyArray<T>::Capacity() const
{
return capacity_;
}
template<typename T>
bool CMyArray<T>::Empty() const
{
return !size_;
}
template<typename T>
void CMyArray<T>::Reserve(size_t len)
{
if (len > size_)
{
for (size_t index = size_; index < len; ++index)
{
Push_back("");
}
}
}
template<typename T>
T& CMyArray<T>::operator[](size_t index)
{
return const_cast<T&>(static_cast<const CMyArray &>(*this)[index]);
}
template<typename T>
const T & CMyArray<T>::operator[](size_t index) const
{
return data_[index];
}
template<typename T>
T & CMyArray<T>::At(size_t index)
{
return const_cast<T &>(static_cast<const CMyArray &>(*this).At(index));
}
template<typename T>
const T & CMyArray<T>::At(size_t index) const
{
size_t temp = index;
if (index >= size_)
{
std::cout << "超出范围" << std::endl;
temp = size_ - 1;
}

return data_[temp];
}
template<typename T>
T & CMyArray<T>::Front()
{
return const_cast<T &>(static_cast<const CMyArray &>(*this).Front());
}
template<typename T>
const T & CMyArray<T>::Front() const
{
return At(0);
}
template<typename T>
T & CMyArray<T>::Back()
{
return const_cast<T &>(static_cast<const CMyArray &>(*this).Back());
}
template<typename T>
const T & CMyArray<T>::Back() const
{
return At(size_ - 1);
}
template<typename T>
void CMyArray<T>::Assign(size_t len, const T & other)
{
delete[] data_;
memset(data_, 0, capacity_ * sizeof(T));
if (len < size_)
{
for (size_t index = 0; index < len; ++index)
{
data_[index] = other;
}
}
else
{
size_ = len;
while (capacity_ < size_)
{
capacity_ *= 2;
}
data_ = new T[capacity_];
for (size_t index = 0; index < size_; ++index)
{
data_[index] = other;
}
}
}
template<typename T>
void CMyArray<T>::Push_back(const T & val)
{
while (capacity_ < size_)
{
capacity_ += 5;
}
T *temp = new T[size_ + 1];
for (size_t i = 0; i < size_; ++i)
{
temp[i] = data_[i];
}
temp[size_] = val;
size_ += 1;
delete[] data_;
data_ = temp;
}
template<typename T>
void CMyArray<T>::Pop_back()
{
T *temp = new T[capacity_];
memset(temp, 0, capacity_ * sizeof(T));
--size_;
for (size_t index = 0; index < size_; ++index)
{
temp[index] = data_[index];
}
delete[] data_;
data_ = temp;
}
template<typename T>
void CMyArray<T>::Insert(size_t pos, size_t len, const T & other)
{
T *temp = new T[size_ + len];
for (size_t index = 0; index < pos; ++index)
{
temp[index] = data_[index];
}
for (size_t index = pos; index < pos + len; ++index)
{
temp[index] = other;
}
for (size_t index = pos + len; index < size_ + len; ++index)
{
temp[index] = data_[index - len];
}
size_ += len;
delete[] data_;
data_ = temp;
}
template<typename T>
T * CMyArray<T>::Erase(size_t pos)
{
T *temp = new T[capacity_];
memset(temp, 0, capacity_ * sizeof(T));
for (size_t index = 0; index < pos; ++index)
{
temp[index] = data_[index];
}
for (size_t index = pos; index < size_ - 1; ++index)
{
temp[index] = data_[index + 1];
}
--size_;
delete[] data_;
data_ = temp;

return &(data_[pos]);
}
template<typename T>
T * CMyArray<T>::Erase(size_t first, size_t last)
{
T *temp = new T[capacity_];
memset(temp, 0, capacity_ * sizeof(T));
for (size_t index = 0; index < first; ++index)
{
temp[index] = data_[index];
}
for (size_t index = first; index < size_ - (last - first); ++index)
{
temp[index] = data_[index + last - first];
}

size_ -= (last - first);
delete[] data_;
data_ = temp;

return &(data_[first]);
}
template<typename T>
void CMyArray<T>::Swap(CMyArray & other)
{
CMyArray temp(other);
other = *this;
*this = temp;
}
template<typename T>
void CMyArray<T>::Clear()
{
delete[] data_;
}
}

#endif // !_MYARRAY_H_

/*MyArray.cpp*/

#include "MyArray.h"
#include "MyString.h"

namespace PoEdu
{

}

Test

#include <iostream>
#include <string>
#include <vector>

#include "MyString.h"
#include "MyArray.h"

int main()
{
PoEdu::CMyArray<PoEdu::CMyString> demo;
demo.Push_back("11111111");
demo.Push_back("22222222");
demo.Push_back("33333333");
demo.Push_back("44444444");
demo.Push_back("55555555");
demo.Push_back("66666666");
demo.Push_back("77777777");
demo.Push_back("88888888");

for (unsigned int i = 0; i < demo.Size(); ++i)
{
std::cout << demo.At(i) << std::endl;
}
std::cout << std::endl;

// 删除下标为3的元素
demo.Erase(3);

for (unsigned int i = 0; i < demo.Size(); ++i)
{
std::cout << demo.At(i) << std::endl;
}
std::cout << std::endl;

system("pause");
return 0;
}