Ok updated version:
reverseDemo.cpp:
Code:
1 #include <iostream>
2 #include <list>
3
4 #include "reverse_access.hpp"
5
6 int main()
7 {
8 std::list<int> someInts;
9 for (int i = 0; i != 10; ++i)
10 someInts.push_back(i * i);
11
12 for (int v : reverse_access(someInts)) // basic usage
13 std::cout << v << ' ';
14 std::cout << std::endl;
15
16 const std::list<int> constSomeInts(someInts);
17 for (int v : reverse_access(constSomeInts)) // const usage
18 std::cout << v << ' ';
19 std::cout << std::endl;
20
21 for (int v : reverse_access(std::list<int>(someInts))) // temporary usage
22 std::cout << v << ' ';
23 std::cout << std::endl;
24
25 int someIntsStatic[] = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81};
26 for (int v : reverse_access(someIntsStatic)) // static array usage
27 std::cout << v << ' ';
28 std::cout << std::endl;
29
30 const int constSomeIntsStatic[] = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}; // const static array usage
31 for (int v : reverse_access(constSomeIntsStatic))
32 std::cout << v << ' ';
33 std::cout << std::endl;
34
35 return 0;
36 }
output:
Code:
81 64 49 36 25 16 9 4 1 0
81 64 49 36 25 16 9 4 1 0
81 64 49 36 25 16 9 4 1 0
81 64 49 36 25 16 9 4 1 0
81 64 49 36 25 16 9 4 1 0
reverse_access.hpp:
Code:
1 #ifndef REVERSE_ACCESS_HPP
2 #define REVERSE_ACCESS_HPP
3
4 #include <cstddef>
5
6 template <typename container>
7 class reverse_access_class
8 {
9 private:
10 container& c_;
11
12 public:
13 reverse_access_class(container& c) : c_(c) { }
14
15 inline decltype(c_.rbegin()) begin() const { return c_.rbegin(); }
16 inline decltype(c_.rend()) end() const { return c_.rend(); }
17 };
18
19 template <typename T>
20 class reverse_access_static_array_class
21 {
22 private:
23 T* s_array_;
24 std::size_t size_;
25
26 class iterator
27 {
28 private:
29 T* s_array_;
30 std::size_t index_plus1_; // 0 needs to indicate 1 before the beginning of the array
31
32 public:
33 iterator(T* s_array, std::size_t index_plus1)
34 :
35 s_array_(s_array),
36 index_plus1_(index_plus1)
37 {
38 }
39
40 iterator& operator++() { --index_plus1_; return *this; }
41 T& operator*() const { return s_array_[index_plus1_ - 1]; }
42 bool operator!=(const iterator& rhs) const { return index_plus1_ != rhs.index_plus1_; }
43 };
44
45 public:
46 reverse_access_static_array_class(T s_array[], std::size_t size)
47 :
48 s_array_(s_array),
49 size_(size)
50 {
51 }
52
53 iterator begin() const { return iterator(s_array_, size_); }
54 iterator end() const { return iterator(s_array_, 0); }
55 };
56
57 template <typename container>
58 inline reverse_access_class<container> reverse_access(container& c)
59 {
60 return reverse_access_class<container>(c);
61 }
62
63 template <typename container>
64 inline reverse_access_class<const container> reverse_access(const container& c)
65 {
66 return reverse_access_class<const container>(c);
67 }
68
69 template <typename T, std::size_t size>
70 inline reverse_access_static_array_class<T> reverse_access(T (&s_array)[size])
71 {
72 return reverse_access_static_array_class<T>(s_array, size);
73 }
74
75 #endif // REVERSE_ACCESS_HPP