c++ STL 学习记录 草稿。
非常丑陋的尝试实现stl。慢慢修改吧。
1）简单实现 vector和list。
2）思索如何开始编写算法。
1，所有容器继承一个抽象容器。那么算法就可以使用抽象基类的next方法来遍历元素。 容器间耦合太高，放弃。
2，所有容器的元素T继承一个基类，算法使用基类的next方法来遍历元素。应该是可以的。做到一半，实现多态时，必须太多指针样子，好像跟stl的使用相差太远。看书发现stl是用模板模拟多态。或者说是模板的正宗，优雅的多态形式。
3，使用模板的更优雅的多态思想来实现容器的迭代器。
3）后面的改进，在于迭代器修改为pointerlike的类。还有书上谈到把各自的迭代器放入到容器类中？以免迭代器暴露太多容器细节。为什么不可以用容器的public方法？
第一版
main
#include <iostream> #include "myvecotr.h" #include "al.h" #include <algorithm> #include <vector> #include "mylist.h" using namespace std; class Book { public: Book(int _id,const string& _name):id(_id),name(_name){} int GetInt() { return id; } string GetName() { return name; } bool operator==(const Book& rhg) { bool ret=false; if(rhg.id==this->id && rhg.name==this->name) { ret=true; } return ret; } private: int id; string name; }; int main() { Book cc(1,"c++"); Book cc2(5,"c"); Book cc3(3,"c#"); cout<<"*************stl*********************"<<endl; vector<Book> books2; books2.push_back(cc); books2.push_back(cc2); books2.push_back(cc3); vector<Book>::iterator myit=books2.begin(); cout<<myit->GetName()<<endl; cout<<"*************list*********************"<<endl; MyList<Book> bookList; bookList.push_back(cc); bookList.push_back(cc2); bookList.push_back(cc3); cout<<bookList.GetHead()->GetV()->GetName()<<endl; ListIterator<Book> FF= myFind(bookList.getFirstIterator(),bookList.getIterator(2),cc3); cout<<FF.GetP()->GetV()->GetName()<<endl; myVector<Book> books; books.push_back(cc); books.push_back(cc2); books.push_back(cc3); cout<<"*************vector*********************"<<endl; myVector<Book>::iterator rnt=myFind(books.GetBegin(),books.GetEnd(),cc2); cout<<rnt->GetName()<<endl; return 0; }
mylist.h
#ifndef MYLIST_H_INCLUDED #define MYLIST_H_INCLUDED #include <memory> #include <stdexcept> #include <iostream> using namespace std; ////////////////////listnode. template<typename T> class ListNode { public: ListNode( T*,ListNode*); void SetNext(ListNode*); ListNode* GetNext(); bool IsEmpty(); T* GetV(); private: T* value; ListNode* next; }; template<typename T> ListNode<T>::ListNode( T* v,ListNode* n):value(v),next(n){} template<typename T> void ListNode<T>::SetNext(ListNode* n) { next=n; } template<typename T> ListNode<T>* ListNode<T>::GetNext() { return next; } template<typename T> bool ListNode<T>::IsEmpty() { if(value==0 && next==0) { return true; } else { return false; } } template<typename T> T* ListNode<T>::GetV() { return value; } /////////////////////////////////list iterator //1)必须有正确的+号操作和!=操作.2)必须有全局的元素和迭代器==的重载. template<typename T> class ListIterator { public: ListIterator(ListNode<T>* v):myP(v){} ListIterator operator+(int index) { ListNode<T>* pListNode=myP; for(int i=0;i!=index;++i) { if(pListNode->GetNext()!=0) { pListNode=pListNode->GetNext(); } else { break; } } return ListIterator(pListNode); } bool operator!=(const ListIterator& rht) { return myP!=rht.myP; } ListNode<T>* GetP() { return myP; } private: ListNode<T>* myP; }; template<typename T> bool operator==( ListIterator<T>& lht, T& rht) { return rht==*(lht.GetP()->GetV()); } /////////////////////////////////mylist template<typename T> class MyList { public: MyList():head(0),size(0){} void push_back(const T& v) { ListNode<T>* tempNode=new ListNode<T>(new T(v),0); if(head==0) { head=tempNode; ++size; } else { ListNode<T>* temp=head; while(temp->GetNext()!=0) { temp=temp->GetNext(); } temp->SetNext(tempNode); ++size; } } ListNode<T>* GetHead() { return head; } ListIterator<T> getFirstIterator() { return ListIterator<T>(head); } ListIterator<T> getIterator(int i) { ListNode<T>* rnt=0; if(i>=0) { ListNode<T>* temp=head; for(int index=0;index!=i;++index) { ListNode<T>* temp2=temp->GetNext(); if(temp2!=0) { temp=temp2; cout<<temp<<endl; } else { break; } } rnt=temp; } return ListIterator<T>(rnt); } ~MyList() { ListNode<T>* temp=head; while(temp!=0) { ListNode<T>* del=temp; temp=temp->GetNext(); delete del->GetV(); delete del; } } private: int size; ListNode<T>* head; }; #endif // MYLIST_H_INCLUDED
myvector.h
#ifndef MYVECTOR_H_INCLUDED #define MYVECTOR_H_INCLUDED //allocator<T> a; 定义一个T类型的allocator对象。 //a.allocate(n); 申请n个T大小的，未分配的空间。类似(T*) malloc(sizeof(T)*n) //a.deallocate(p,n) 释放内存,p为T*，n为释放的T类型对象的数量。注意：T类型对象本身，如有需要释放的资源，必须先释放，a.deallocate(p,n)只是释放对象本身的内存，而对象的建立又额外申请的资源，需要另外处理。 //a.construct(p,t) 复制构造，用t来复制构造。相当于 new (p) T(t),这个是placement new的用法 new(place_address) type(initializer-list) //a.destroy(p) 调用pd对象的析构函数。 //uninitialized_copy(startit,endit,it) startit,endit ：要复制的开始迭代器地址和结束地址。it:要复制的迭代器地址。 //uninitialized_fill(startit,endit,obj) startit,endit ：要复制的开始迭代器地址和结束地址。it:要复制的对象。 使用复制构造函数填充内存 //uninitialized_fill_n(startit,endit,obj,n) startit,endit ：要复制的开始迭代器地址和结束地址。it:要复制的对象。 n，要复制的数量。 使用复制构造函数填充内存 //因为是模板,有类型参数,类的方法编译的时候,不能确定所占用的栈大小.必须使用的时候才能确定,而且不同的T类型,有不同的方法地址.所以申明定义放到一起 #include <memory> #include <stdexcept> #include <iostream> #include "myitertor.h" using namespace std; template<typename T> class myVector{ public: //如果分配错误呢? myVector():pbegin(myalloc.allocate(defautlSize)),pend(pbegin),pcapcity(pbegin+defautlSize),Vsize(0),Vcapcity(defautlSize){} typedef T* iterator; void push_back(const T& _obj) { if(pend>=pcapcity) { T* pTempAlloc=myalloc.allocate(Vcapcity*2); T* pPrep=pbegin; if(pTempAlloc!=0) { uninitialized_copy(pbegin,pend,pTempAlloc); pbegin=pTempAlloc; pend=pbegin+Vsize; pcapcity=pbegin+(Vcapcity*2); Vsize=Vsize; Vcapcity+=Vcapcity; //清理原资源. destroyS(pPrep,pPrep+Vsize,pPrep+Vsize); } else { throw runtime_error("error allocator!"); } } myalloc.construct(pend,_obj); ++pend; ++Vsize; } void erase(unsigned int index) { if(index>=0&& index<Vsize) { myalloc.destroy(pbegin+index);//手动调用对象析构 for(int i=index+1;i!=Vsize;++i)//往前覆盖.最后一个对象占用的内存,不管了.pend往前移动就好. { uninitialized_copy(pbegin+i,pbegin+i+1,pbegin+i-1); } --Vsize; --pend; } else { throw runtime_error("index over range."); } } ~myVector() { destroyS(pbegin,pend,pcapcity); } myVector(const myVector& _obj) { pbegin=myalloc.allocate(_obj.Vcapcity); pend=pbegin+_obj.Vsize; pcapcity=pbegin+_obj.Vcapcity; Vsize=_obj.Vsize; Vcapcity=_obj.Vcapcity; uninitialized_copy(_obj.pbegin,_obj.pend,pbegin); } myVector& operator=(const myVector& _obj) { if(&_obj!=this) { destroyS(pbegin,pend,pcapcity); pbegin=myalloc.allocate(_obj.Vcapcity); pend=pbegin+_obj.Vsize; pcapcity=pbegin+_obj.Vcapcity; Vsize=_obj.Vsize; Vcapcity=_obj.Vcapcity; uninitialized_copy(_obj.pbegin,_obj.pend,pbegin); } return *this; } int size() { return pend-pbegin; } int capcity() { return pcapcity-pbegin; } void showInfo() { cout<<"pbegin:"<<(void *)pbegin<<". size:"<<Vsize<<". capcity"<<Vcapcity<<". pend:"<<(void *)pend<<endl; T* pb=pbegin; for(pb;pb!=pend;++pb) { cout<<*pb<<endl; } } T& operator[](int index) { return *(pbegin+index); } T* GetBegin() { return pbegin; } T* GetEnd() { return pend; } private: static allocator<T> myalloc; const static int defautlSize=3; T* pbegin; T* pend; T* pcapcity; unsigned int Vcapcity; unsigned int Vsize; void destroyS(T* PS,T* PE,T* PC) { T* pb=PS; for(pb;pb!=PE;++pb) { myalloc.destroy(pb);//仅仅调用析构函数. } myalloc.deallocate(PS,PC-PS); } }; //int book::pid=6 template<typename T> allocator<T> myVector<T>::myalloc=allocator<T>(); template<typename T> bool operator==(T* a,T v) { bool rnt; if(*a==v) { rnt=true; } else { rnt=false; } return rnt; } #endif // MYVECTOR_H_INCLUDED
al.h
#ifndef AL_H_INCLUDED #define AL_H_INCLUDED #include "myitertor.h" //1)必须有正确的+号操作和!=操作.2)必须有全局的元素和迭代器==的重载. template<typename T,typename MyInputIterator> MyInputIterator myFind(MyInputIterator start,MyInputIterator end, T& value) { for(start;start!=end;start=start+1) { if(start==value)// { break; } } return start; } #endif // AL_H_INCLUDED
hashtable:
自己写的 hashtable，不过hash函数还是stl的hash ,而且冲突时的链表也是直接使用stl的list。
之前写了几次总放弃，重要是考虑太多，自己造hash的轮子，总感觉不适用，一直停在那里。又考虑list 的具体细节。还要和这里配合。
感觉造轮子前，先使用木头，而不要先造斧头，去砍树。这样造个轮子都要很耗精力。
等轮子造好了，再去造斧头。再去造炉子，再去造火。要不然会总停在某个点上。
造轮子的目的其实是理解。方便选择适合的场景使用适当的数据结构。
最终的目的是使用标准的轮子。而不是自己的轮子。
从难学。从易用。切记。。。
#include <iostream> #include "stdio.h" #include <memory> #include <unistd.h> #include <thread> #include <vector> #include <algorithm> #include <memory.h> #include <map> #include <list> #include <ext/hash_map> using namespace std; using namespace __gnu_cxx; struct Good { int gid; string goodName; int value; }; namespace __gnu_cxx { template<> struct hash<string> { size_t operator()(const string& s) const { return __stl_hash_string(s.c_str()); } }; } template<typename T> class HashTable { public: class Hashv { public: string key; T value; }; HashTable(int32_t v) { ht=new list<Hashv>[v]; ht_size=v; } int32_t hash(const string& _key) { std::hash<string> sh; size_t hv= sh(_key); hv=hv%ht_size; return hv; } bool Add(const string& key,const T& _v) { int32_t _hash_index=hash(key); Hashv temp; temp.key=key; temp.value=_v; ht[_hash_index].push_back(temp); return true; } T Search(string _key) { int32_t _hash_index=hash(_key); T ret; if(ht[_hash_index].size()==1) { ret= ht[_hash_index].begin()->value; } else { for(auto obj : ht[_hash_index]) { if(obj.key==_key) { ret= obj.value; } } } return ret; } ~HashTable() { delete[] ht; } private: list<Hashv> * ht; int32_t ht_size; }; void main2(); int main() { //map map<int,Good> good_buff; for(int i=0;i<10000;++i) { Good temp; temp.gid=i; temp.goodName="test"; temp.value=i%100+1; good_buff.insert(map<int,Good>::value_type(temp.gid,temp)); } int gid=405; if(good_buff.find(gid)!=good_buff.end()) { cout<<good_buff[gid].value<<endl; } //simple hashtable HashTable<Good> myhash(100); Good temp; temp.gid=3; temp.goodName="test"; temp.value=31; myhash.Add("3",temp); Good temp2; temp2.gid=4; temp2.goodName="test"; temp2.value=41; myhash.Add("4",temp2); Good ss=myhash.Search("4"); cout<<ss.value<<endl; //stl hash map. hash_map<string,Good> stlhash; stlhash.insert(hash_map<string,Good>::value_type("test",temp)); stlhash.insert(hash_map<string,Good>::value_type("test2",temp)); hash_map<string,Good>::iterator ss2=stlhash.find("test"); cout<<ss2->second.value<<endl; int cmd; cin>>cmd; }
