stl 学习笔记 12

//cont/array1.cpp




/**//*


======================


array 可以做为stl容器。但不提供 begin()和end(),也不提供任何成员函数


======================


*/


#include <iostream>


#include <algorithm>


#include <functional>


using namespace std;




int main()




...{




int coll[] = ...{5,6,2,4,1,3};


transform(coll,coll+6,coll,coll,multiplies<int>());


sort(coll+1,coll+6);


copy(coll,coll+6,ostream_iterator<int>(cout," "));


cout <<endl;


}






/**//*


result


====================


25 1 4 9 16 36


*/

数组外包装，在数组外包装一层常用的容器界面，性能不输一般的数组，而且更安全


//stl/carray.h


#ifndef CARRAY_H


#define CARRAY_H




#include <cstddef>




template <class T,std::size_t thesize>


class carray




...{


private:


T v[thesize];


public:


typedef T value_type;


typedef T* iterator;


typedef const T* const_iterator;


typedef T& reference;


typedef const T& const_reference;


typedef std::size_t size_type;


typedef std::ptrdiff_t difference_type;






iterator begin() ...{return v;}




const_iterator begin() const ...{ return v;}




iterator end() ...{return v+thesize;}




const_iterator end() const ...{return v+thesize;}




reference operator[](std::size_t i)




...{return v[i];}


const_iterator operator[](std::size_t i) const




...{return v[i];}




size_type size() const




...{return thesize;}


size_type max_size() const




...{return thesize;}




T* as_array()




...{return v;}


};




#endif








#include <iostream>


#include <functional>


#include <algorithm>


#include "print.h"


#include "carray.h"


using namespace std;




int main()




...{


carray<int,10> a;




for(unsigned i = 0; i <a.size();++i)


a[i] =i+1;




PRINT_ELEMENTS(a);




reverse(a.begin(),a.end());


PRINT_ELEMENTS(a);


transform(a.begin(),a.end(),a.begin(),negate<int>());


PRINT_ELEMENTS(a);


}






/**//*


result


================================


1 2 3 4 5 6 7 8 9 10


10 9 8 7 6 5 4 3 2 1


-10 -9 -8 -7 -6 -5 -4 -3 -2 -1


*/


#ifndef COUNTER_PRT_H


#define COUNTER_PTR_H




/**//*


stl 容器提供的是value 语义 而不是 reference 语义，他在内部共建了元素的副本，有时候元素复制的代价过大，就要采用


智能型指针。这是个解决办法，采用的是 reference counting(参考计数)智能型指针。


*/




template <typename T>


class CountedPtr




...{


private:


T* ptr; //ptr


long* count; //counting


public:


explicit CountedPtr(T* p = 0) // 避免 = 的类型转换


:ptr(p),count(new long(1))




...{}




CountedPtr(const CountedPtr<T>& p) throw() // 拷贝构造函数，++counter


:ptr(p.ptr),count(p.count)




...{


++*count;


}


~CountedPtr() throw()




...{


dispose();


}


CountedPtr<T>& operator=(const CountedPtr<T>& p) throw() // =




...{


if(this != &p)




...{


dispose();


ptr = p.ptr;


count = p.count;


++*count;


}


return *this;


}




T& operator*()const throw() // *




...{


return *ptr;


}




T* operator ->()const throw() // ->




...{


return ptr;


}




private:


void dispose() //dispose




...{


if(--*count == 0)




...{


delete count;


delete ptr;


}


}


};


#endif


//stl/refsem1.cpp




/**//*


===================================================================


如何使用countedPtr<T>


===================================================================


*/


#include <iostream>


#include <list>


#include <deque>


#include <algorithm>


#include "countptr.h"


using namespace std;




void PrintCountedPtr(CountedPtr<int> elem)




...{


cout <<*elem <<' ';


}




int main()




...{




static int values[] = ...{3,5,9,1,6,4};


typedef CountedPtr<int> IntPtr;


deque<IntPtr> coll1;


list<IntPtr> coll2;




for(int i = 0; i <sizeof(values)/sizeof(values[0]);++i)




...{


IntPtr ptr(new int(values[i]));


coll1.push_back(ptr);


coll2.push_front(ptr);


}




for_each(coll1.begin(),coll1.end(),PrintCountedPtr);


cout <<endl;


for_each(coll2.begin(),coll2.end(),PrintCountedPtr);


cout <<endl <<endl;




*coll1[2] *= *coll1[2];


(**coll1.begin()) *= -1;


(**coll2.begin()) = 0;




for_each(coll1.begin(),coll1.end(),PrintCountedPtr);


cout <<endl;


for_each(coll2.begin(),coll2.end(),PrintCountedPtr);


cout <<endl;


return 0;


}






/**//*


result


===========================


3 5 9 1 6 4


4 6 1 9 5 3




-3 5 81 1 6 0


0 6 1 81 5 -3


*/