Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #include <cstddef>
- #include <iostream>
- #include <iterator>
- #include <limits>
- #include <memory>
- template <typename T>
- class ScaledPointer : public std::iterator<std::random_access_iterator_tag, T> {
- T* ptr;
- public:
- ScaledPointer() = default;
- ScaledPointer(T* ptr) : ptr(ptr) {}
- template <typename U>
- explicit ScaledPointer(U* ptr) : ptr(static_cast<T*>(ptr)) {}
- template <typename U>
- explicit ScaledPointer(const ScaledPointer<U>& other) :
- ptr(static_cast<T*>(other.ptr)) {}
- explicit operator bool () const { return bool{ptr}; }
- T& operator * () const {
- return *ptr;
- }
- T* operator -> () const {
- return ptr;
- }
- T& operator [] (std::ptrdiff_t n) const {
- return ptr[2 * n];
- }
- ScaledPointer& operator ++ () {
- ptr += 2;
- return *this;
- }
- ScaledPointer operator ++ (int) {
- ScaledPointer tmp(*this);
- ++*this;
- return tmp;
- }
- ScaledPointer& operator -- () {
- ptr -= 2;
- return *this;
- }
- ScaledPointer operator -- (int) {
- ScaledPointer tmp(*this);
- --*this;
- return tmp;
- }
- template <typename U, typename V>
- friend bool operator == (const ScaledPointer<U>& u, const ScaledPointer<V>& v) {
- return u.ptr == v.ptr;
- }
- template <typename U, typename V>
- friend bool operator != (const ScaledPointer<U>& u, const ScaledPointer<V>& v) {
- return !(u == v);
- }
- template <typename U, typename V>
- friend bool operator < (const ScaledPointer<U>& u, const ScaledPointer<V>& v) {
- return u.ptr < v.ptr;
- }
- template <typename U, typename V>
- friend bool operator > (const ScaledPointer<U>& u, const ScaledPointer<V>& v) {
- return v < u;
- }
- template <typename U, typename V>
- friend bool operator <= (const ScaledPointer<U>& u, const ScaledPointer<V>& v) {
- return !(v < u);
- }
- template <typename U, typename V>
- friend bool operator >= (const ScaledPointer<U>& u, const ScaledPointer<V>& v) {
- return !(u < v);
- }
- ScaledPointer& operator += (std::ptrdiff_t n) {
- ptr += 2 * n;
- return *this;
- }
- friend ScaledPointer operator + (const ScaledPointer& u, std::ptrdiff_t n) {
- ScaledPointer tmp = u;
- tmp += n;
- return tmp;
- }
- ScaledPointer& operator -= (std::ptrdiff_t n) {
- ptr -= 2 * n;
- return *this;
- }
- friend ScaledPointer operator - (const ScaledPointer& u, std::ptrdiff_t n) {
- ScaledPointer tmp = u;
- tmp -= n;
- return tmp;
- }
- friend std::ptrdiff_t operator - (const ScaledPointer& a, const ScaledPointer& b) {
- return (a.ptr - b.ptr) / 2;
- }
- };
- template <typename T>
- class ScaledAllocator {
- public:
- typedef ScaledPointer<T> pointer;
- typedef T value_type;
- typedef std::size_t size_type;
- pointer allocate(size_type n) {
- const std::size_t size = (n * (2 * sizeof(T)));
- void* p = ::operator new(size);
- std::cout << __FUNCTION__ << '(' << n << ") = " << p << std::endl;
- std::fill_n((unsigned*)p, size / sizeof(unsigned), 0xFEEDFACEU);
- return pointer{p};
- }
- void deallocate(pointer p, size_type n) {
- std::cout << __FUNCTION__ << '(' << &*p << ", " << n << ')' << std::endl;
- ::operator delete(&*p);
- }
- static size_type max_size() {
- return std::numeric_limits<size_type>::max() / 2;
- }
- template <typename U, typename V>
- friend bool operator == (const ScaledAllocator<U>&, const ScaledAllocator<V>&) {
- return true;
- }
- template <typename U, typename V>
- friend bool operator != (const ScaledAllocator<U>&, const ScaledAllocator<U>&) {
- return false;
- }
- };
- #include <algorithm>
- #include <vector>
- int main() {
- using namespace std;
- cout << hex << showbase;
- vector<unsigned, ScaledAllocator<unsigned>> vec = {0,1,2,3,4};
- for_each(begin(vec), end(vec), [](unsigned i){ cout << i << ' '; });
- cout << endl;
- auto p = vec.data();
- for(auto i = decltype(vec.size()){0}, n = vec.size(); i < n; ++i)
- cout << p[i] << ' ';
- cout << endl;
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement