From 776b1592e3d67f7a1af94180a0b4c3fcf5320f96 Mon Sep 17 00:00:00 2001 From: Wolfgang Draxinger Date: Fri, 19 Jul 2019 15:21:19 +0200 Subject: same container, mixed type required per type allocator template parameters --- example/Makefile | 8 +++++++- example/operators.cc | 33 +++++++++++++++++++++++++------- include/dwu/operators | 52 ++++++++++++++++++++++++++++++++++++++++----------- 3 files changed, 74 insertions(+), 19 deletions(-) diff --git a/example/Makefile b/example/Makefile index c96a553..0e50a44 100644 --- a/example/Makefile +++ b/example/Makefile @@ -1,8 +1,14 @@ CXXFLAGS+=-Wall -Werror -I../include -.PHONY: all +.PHONY: all clean all: operators +clean: + -rm operators + -rm operators.o + operators: CC=$(CXX) operators: operators.o + +operators.o: operators.cc ../include/dwu/operators Makefile diff --git a/example/operators.cc b/example/operators.cc index 14fa00b..68033dc 100644 --- a/example/operators.cc +++ b/example/operators.cc @@ -5,22 +5,20 @@ #include #include - template static void dump(S const &s, T const &v) { std::cout << s << '{'; - for( auto const &x : v ){ - std::cout << x << ", "; - } + for( auto const &x : v ){ std::cout << x << ", "; } std::cout << '}' << std::endl; } int main(int argc, char *argv[]) { + // syntactic sugar operators for same container, same type using namespace dwu::operators; - std::vector va = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; + std::vector va = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; dump("va: ", va); auto vb = va + 10; @@ -37,12 +35,33 @@ int main(int argc, char *argv[]) dump("vd = vb * vc: ", vd); { + // syntactic sugar for mixed container, mixed type using namespace dwu::operators_xcxt; std::list la = {100, 101, 101, 103, 104, 105}; dump("la: ", la); - auto rr = la - vd; - dump("rr = la - vd: ", rr); + auto r_ad = la - vd; + dump("r_ad = la - vd: ", r_ad); + } + + { + // syntactic sugar for mixed container, same type + using namespace dwu::operators_xc; + std::list lb = {200, 201, 201, 203, 204, 205}; + dump("lb: ", lb); + + auto r_bd = lb + vd; + dump("r_bd = lb + vd: ", r_bd); + } + + { + // syntactic sugar for same container, mixed type + using namespace dwu::operators_xt; + std::vector ve = {300, 301, 301, 303, 304, 305}; + dump("ve: ", ve); + + auto r_ed = ve / vd; + dump("r_ed = ve / vd: ", r_ed); } return 0; diff --git a/include/dwu/operators b/include/dwu/operators index bb52a57..fde9118 100644 --- a/include/dwu/operators +++ b/include/dwu/operators @@ -23,7 +23,31 @@ #ifndef DWU__OPERATORS__ #define DWU__OPERATORS__ 1 +/* === Implementation Notes === + + == On the use of explicitly implemented min instead of std::min == + +Within the operator functions that work on two containers, the output +length is truncated to the shorter of the two containers by an explicitly +written out min-comparison, like this: + + auto const lsz = l.size(); auto const rsz = r.size(); + Cl v( (lsz < rsz) ? lsz : rsz ); + +This is used instead of container for two reasons: + + 1. It avoids inclusion of a header. Although is rather + lightweight, the extra compile time is measureable. + + 2. std::min expects both inputs to be strictly of the same type. This + however makes it impossible to do mixed container operation with + containers that use a different size type, which however is something + we want to support. + +**/ + namespace dwu { + namespace operators { // same container, same type #define DWU_OPERATORS(O) \ @@ -84,9 +108,10 @@ DWU_OPERATORS(|) #define DWU_OPERATORS_XT(O) \ template< \ template class C, \ - typename Tl, typename A, typename Tr > \ - C operator O (C const &l, Tr const &r) { \ - C v(l.size()); \ + typename Tl, typename Al, \ + typename Tr, typename Ar > \ + C operator O (C const &l, Tr const &r) { \ + C v(l.size()); \ auto vi = v.begin(); auto li = l.begin(); \ while( vi != v.end() ){ \ *vi++ = *li++ O r; \ @@ -95,9 +120,10 @@ DWU_OPERATORS(|) } \ template< \ template class C, \ - typename Tl, typename A, typename Tr > \ - C operator O (Tl const &l, C const &r) { \ - C v(r.size()); \ + typename Tl, typename Al, \ + typename Tr, typename Ar > \ + C operator O (Tl const &l, C const &r) { \ + C v(r.size()); \ auto vi = v.begin(); auto ri = r.begin(); \ while( vi != v.end() ){ \ *vi++ = l O *ri++; \ @@ -106,10 +132,11 @@ DWU_OPERATORS(|) } \ template< \ template class C, \ - typename Tl, typename A, typename Tr > \ - C operator O (C const &l, C const &r) { \ + typename Tl, typename Al, \ + typename Tr, typename Ar > \ + C operator O (C const &l, C const &r) { \ auto const lsz = l.size(); auto const rsz = r.size(); \ - C v( (lsz < rsz) ? lsz : rsz ); \ + C v( (lsz < rsz) ? lsz : rsz ); \ auto vi = v.begin(); auto li = l.begin(); auto ri = r.begin(); \ while( vi != v.end() ){ \ *vi++ = *li++ O *ri++; \ @@ -118,8 +145,9 @@ DWU_OPERATORS(|) } \ template< \ template class C, \ - typename Tl, typename A, typename Tr > \ - C& operator O##= (C &l, Tr const &r){ \ + typename Tl, typename Al, \ + typename Tr, typename Ar > \ + C& operator O##= (C &l, Tr const &r){ \ for(auto &x:l){ x O##= r; } \ return l; \ } @@ -211,5 +239,7 @@ DWU_OPERATORS_XCXT(&) DWU_OPERATORS_XCXT(|) #undef DWU_OPERATORS_XCXT } + } + #endif/*DWU__OPERATORS__*/ -- cgit v1.2.3